#include "StdAfx.h"
#include "CHReviewResult/GlassResult.h"

using namespace CHReviewResult;

double CGlassResult::CalculateDistance(int nPosX, int nPosY, int nGrabX, int nGrabY)
{
	double dx = double(nPosX-nGrabX) / 1000.0;
	double dy = double(nPosY-nGrabY) / 1000.0;

	return sqrt(dx*dx + dy*dy);
}

CGlassResult::CGlassResult(void)
{
	InitializeCriticalSection(&m_csProcess);
	InitializeCriticalSection(&m_csDefect);
	Reset(); 
}

CGlassResult::~CGlassResult(void)
{
	Reset(); 
	DeleteCriticalSection(&m_csProcess);
	DeleteCriticalSection(&m_csDefect);
}

void CGlassResult::Reset()
{
	// current status
	m_bReadRawFile			= FALSE;
	m_nCurDefectIdx			= 0;

	m_dwMinFrameTick		= 200; //ms
	m_nDeFocusCount			= 0;

	m_strGlassLastName		= _T("");

	// glass info
	m_nDivideType			= 0;
	m_nSlotNum				= 0;
	m_nGlassSizeX			= 0;
	m_nGlassSizeY			= 0;
	m_nCollisionDistanceX	= 0;
	m_nCollisionDistanceY	= 0;
	m_nCollisionXPos1 = 0;
	m_nCollisionXPos2 = 0;
	m_nOriginDir			= 0;
	m_nCornerCutDir			= 0;
	m_nReviewSnapSerialNo	= 0;
	m_glassJudge			= 0;
	m_bCenterCoordinate		= FALSE;
	m_bInverseCoordinate	= FALSE;

	m_dDistanceThreshold	= 9999.0;

	//AOI Raw File Path
	m_strAOIRawFileName		= _T("");		//TD
	m_strAOIRawFilePath		= _T("");		//TD
	m_strAOIRawCDFileName	= _T("");		//CD
	m_strAOIRawCDFilePath	= _T("");		//CD
	m_strAOIRawSDFileName	= _T("");		//SD
	m_strAOIRawSDFilePath	= _T("");		//SD


	//Local Raw File Path
	m_strLocalRawFilePath	= _T("");		//TD
	m_strLocalRawCDFilePath = _T("");	//CD
	m_strLocalRawSDFilePath = _T("");	//SD

	// glass transfer info
	m_strLotID = _T("");
	m_strGlassID = _T("");
	m_strRecipeID = _T("default");
	m_strProcessID = _T("");	
	m_strPPID = _T("");
	m_strPPID_RC = _T("");
	m_strStepID = _T("");
	m_strFlowID = _T("");
	m_strFlowHistory = _T("");

	m_strOperID = _T("");
	m_strGlassCode = _T("");

	m_equipID = _T("");


	m_strJobType = _T("");
	m_strJobID = _T("");
	m_strLotSeqNum = _T("");
	m_strSlotSeqNum = _T("");
	m_strPropertyCode = _T("");
	m_strJobJudgeCode = _T("");
	m_strJobGradeCode = _T("");
	m_strSubstrateType = _T("");
	m_strJobSize = _T("");
	m_strGlassThickness = _T("");
	m_strJobAngle = _T("");
	m_strJobFlip = _T("");
	m_strCuttingGlassType = _T("");
	m_strPairJobID = _T("");
	m_strPairFlag = _T("");
	m_strOptionValue = _T("");
	m_strReserved = _T("");


	/////////// 20170825 smok. ph2 element Ãß°¡
	m_strGlassJudgeCode = _T("");

	m_strGlassGradeCode = _T("");

	m_strProdID = _T("");
	m_strProcessingFlag = _T("");
	m_strInspectionJudgeData = _T("");

	m_strSkipFlag = _T("");
	m_strInspectionFlag = _T("");
	m_strMode = _T("");
	m_strGlassType = _T("");
	m_strDummyType = _T("");

	m_strProcessingCount = _T("");

	// time 
	m_strUnLoadingTime = _T("");
	m_strResultDate = _T("");

	// align info
	m_AlignRecipe.Reset();
	m_AlignResult.Reset();

	// cell info
	m_vecCellResult.clear();

	// defect info
	m_vecCrackDefectResult.clear();
	m_vecMaskDefectResult.clear();
	m_vecPadDefectResult.clear();
	m_vecCommonDefectResult.clear();
	m_vecAlignDefectResult.clear();
	m_vecActiveDefectResult.clear();
	m_vecReworkDefectResult.clear();

	// review result info
	m_vecReviewResult.clear();
	m_vecUserResult.clear();
	m_vecWsiResult.clear();
	m_vecMeasureResult.clear();
	m_vecReflowResult.clear();
	m_vecWsiReflowResult.clear();
	m_vecWsiMultiShotResult.clear();

	// review schedule result 
	m_vecReviewScheduleResult.clear();
	m_vecUserScheduleResult.clear();
	m_vecWsiScheduleResult.clear();
	m_vecMeasureScheduleResult.clear();
	m_vecReflowScheduleResult.clear();
	m_vecWsiReflowScheduleResult.clear();
	m_vecWsiMultiShotScheduleResult.clear();

	//FDCº¸°í¿ë Review Contrast
	//#3524_210723_LYW_CF AOI Review µðÆ÷Ä¿½º ¾Ë¶÷ Ãß°¡ ¹× FDC º¸°í ¹æ½Ä °³¼± MOD Start
	nReview00ImageContrast = 5;
	nReview01ImageContrast = 5;
	//#3524_210723_LYW_CF AOI Review µðÆ÷Ä¿½º ¾Ë¶÷ Ãß°¡ ¹× FDC º¸°í ¹æ½Ä °³¼± MOD End

	// defect result
	for (MapDefectResultIt it = m_mapDefectResult.begin(); it != m_mapDefectResult.end(); it++)
	{
		
		CDefectResult* pDefect = static_cast<CDefectResult*>(it->second);
		delete pDefect;
	}
	m_mapDefectResult.clear();
}


void CGlassResult::HT_Reset()
{
	// current status
	m_bReadRawFile = FALSE;
	m_nCurDefectIdx = 0;

	m_dwMinFrameTick = 200; //ms
	m_nDeFocusCount = 0;

	m_strGlassLastName = _T("");

	// glass info
	m_nDivideType = 0;
	m_nSlotNum = 0;
	m_nGlassSizeX = 0;
	m_nGlassSizeY = 0;
	m_nCollisionDistanceX = 0;
	m_nCollisionDistanceY = 0;
	m_nCollisionXPos1 = 0;
	m_nCollisionXPos2 = 0;
	m_nOriginDir = 0;
	m_nCornerCutDir = 0;
	m_nReviewSnapSerialNo = 0;
	m_glassJudge = 0;
	m_bCenterCoordinate = FALSE;
	m_bInverseCoordinate = FALSE;

	m_dDistanceThreshold = 9999.0;

	//AOI Raw File Path
	m_strAOIRawFileName = _T("");		//TD
	m_strAOIRawFilePath = _T("");		//TD
	m_strAOIRawCDFileName = _T("");		//CD
	m_strAOIRawCDFilePath = _T("");		//CD
	m_strAOIRawSDFileName = _T("");		//SD
	m_strAOIRawSDFilePath = _T("");		//SD


	//Local Raw File Path
	m_strLocalRawFilePath = _T("");		//TD
	m_strLocalRawCDFilePath = _T("");	//CD
	m_strLocalRawSDFilePath = _T("");	//SD

	// glass transfer info
	m_strLotID = _T("");
	m_strGlassID = _T("");
	m_strRecipeID = _T("default");
	m_strProcessID = _T("");
	m_strPPID = _T("");
	m_strPPID_RC = _T("");
	m_strStepID = _T("");
	m_strFlowID = _T("");
	m_strFlowHistory = _T("");

	m_strOperID = _T("");
	m_strGlassCode = _T("");

	m_equipID = _T("");


	m_strJobType = _T("");
	m_strJobID = _T("");
	m_strLotSeqNum = _T("");
	m_strSlotSeqNum = _T("");
	m_strPropertyCode = _T("");
	m_strJobJudgeCode = _T("");
	m_strJobGradeCode = _T("");
	m_strSubstrateType = _T("");
	m_strJobSize = _T("");
	m_strGlassThickness = _T("");
	m_strJobAngle = _T("");
	m_strJobFlip = _T("");
	m_strCuttingGlassType = _T("");
	m_strPairJobID = _T("");
	m_strPairFlag = _T("");
	m_strOptionValue = _T("");
	m_strReserved = _T("");


	/////////// 20170825 smok. ph2 element Ãß°¡
	m_strGlassJudgeCode = _T("");

	m_strGlassGradeCode = _T("");

	m_strProdID = _T("");
	m_strProcessingFlag = _T("");
	m_strInspectionJudgeData = _T("");

	m_strSkipFlag = _T("");
	m_strInspectionFlag = _T("");
	m_strMode = _T("");
	m_strGlassType = _T("");
	m_strDummyType = _T("");

	m_strProcessingCount = _T("");

	// time 
	m_strUnLoadingTime = _T("");
	m_strResultDate = _T("");

	// align info
	m_AlignRecipe.Reset();
	m_AlignResult.Reset();

	// cell info
	m_vecCellResult.clear();

	// defect info
	m_vecCrackDefectResult.clear();
	m_vecMaskDefectResult.clear();
	m_vecPadDefectResult.clear();
	m_vecCommonDefectResult.clear();
	m_vecAlignDefectResult.clear();
	m_vecActiveDefectResult.clear();
	m_vecReworkDefectResult.clear();

	// review result info
	m_vecReviewResult.clear();
	m_vecUserResult.clear();
	m_vecWsiResult.clear();
	m_vecMeasureResult.clear();
	m_vecReflowResult.clear();
	m_vecWsiReflowResult.clear();
	m_vecWsiMultiShotResult.clear();

	// review schedule result 
	m_vecReviewScheduleResult.clear();
	m_vecUserScheduleResult.clear();
	m_vecWsiScheduleResult.clear();
	m_vecMeasureScheduleResult.clear();
	m_vecReflowScheduleResult.clear();
	m_vecWsiReflowScheduleResult.clear();
	m_vecWsiMultiShotScheduleResult.clear();

	//FDCº¸°í¿ë Review Contrast
	//#3524_210723_LYW_CF AOI Review µðÆ÷Ä¿½º ¾Ë¶÷ Ãß°¡ ¹× FDC º¸°í ¹æ½Ä °³¼± MOD Start
	nReview00ImageContrast = 50;
	nReview01ImageContrast = 50;
	//#3524_210723_LYW_CF AOI Review µðÆ÷Ä¿½º ¾Ë¶÷ Ãß°¡ ¹× FDC º¸°í ¹æ½Ä °³¼± MOD End
	//// defect result
	//for (MapDefectResultIt it = m_mapDefectResult.begin(); it != m_mapDefectResult.end(); it++)
	//{

	//	CDefectResult* pDefect = static_cast<CDefectResult*>(it->second);
	//	delete pDefect;
	//}
	m_mapDefectResult.clear();
}

void CGlassResult::AddCellResult(const CCellResult& cellResult)  //ºÐÆÇ Á¤º¸? 
{
	CCellResult transResult = cellResult;
	
	if (m_nDivideType==1)		// AºÐÆÇ
	{
		
	}
	else if (m_nDivideType==2)	// BºÐÆÇ
	{

	}

	m_vecCellResult.push_back(transResult);
}


void CGlassResult::AddReviewScheduleResult(const CPathSchedulerResult& scheduleResult)
{
	m_vecReviewScheduleResult.push_back(scheduleResult);
}

void CGlassResult::AddUserScheduleResult(const CPathSchedulerResult& scheduleResult)
{
	m_vecUserScheduleResult.push_back(scheduleResult);
}

void CGlassResult::AddWsiScheduleResult(const CPathSchedulerResult& scheduleResult)
{
	m_vecWsiScheduleResult.push_back(scheduleResult);
}

void CGlassResult::AddMeasureScheduleRedult(const CPathSchedulerResult& scheduleResult)
{
	m_vecMeasureScheduleResult.push_back(scheduleResult);
}

void CGlassResult::AddReflowScheduleRedult( const CPathSchedulerResult& scheduleResult )
{
	m_vecReflowScheduleResult.push_back(scheduleResult);
}

void CGlassResult::AddWsiReflowScheduleRedult( const CPathSchedulerResult& scheduleResult )
{
	m_vecWsiReflowScheduleResult.push_back(scheduleResult);
}

void CGlassResult::AddWsiMultiShotScheduleResult(const CPathSchedulerResult& scheduleResult)
{
	m_vecWsiMultiShotScheduleResult.push_back(scheduleResult);
}

const VectorReviewScheduleResult* CGlassResult::GetVectorWsiMultiShotScheduleResult() const
{
	return &m_vecWsiMultiShotScheduleResult;
}

VectorReviewScheduleResult* CGlassResult::GetVectorWsiMultiShotScheduleResult()
{
	return &m_vecWsiMultiShotScheduleResult;
}

int CGlassResult::GetWsiMultiShotScheduleResultCount() const
{
	return (int)m_vecWsiMultiShotScheduleResult.size();
}

CPathSchedulerResult* CGlassResult::GetWsiMultiShotScheduleResult(int nModuleIdx)
{
	for (VectorReviewScheduleResultIt it = m_vecWsiMultiShotScheduleResult.begin(); it != m_vecWsiMultiShotScheduleResult.end(); it++)
	{
		if (nModuleIdx == it->GetModuleIndex())
		{
			return static_cast<CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

const CPathSchedulerResult* CGlassResult::GetWsiMultiShotScheduleResult(int nModuleIdx) const
{
	for (constVectorReviewScheduleResultIt it = m_vecWsiMultiShotScheduleResult.begin(); it != m_vecWsiMultiShotScheduleResult.end(); it++)
	{
		if (nModuleIdx == it->GetModuleIndex())
		{
			return static_cast<const CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;

}

int CGlassResult::GetWsiMultiShotSSchedulerResultCount(int nModuleIdx) const
{
	const CPathSchedulerResult* pWsiMultiShotScheduleResult = GetWsiMultiShotScheduleResult(nModuleIdx);
	if (pWsiMultiShotScheduleResult == NULL) return -1;
	return pWsiMultiShotScheduleResult->GetPathSchedulerResultCount();
}

SSchedulerResult* CGlassResult::GetWsiMultiShotSSchedulerResult(int nModuleIdx, int nResultIdx)
{
	CPathSchedulerResult* pScheduleResult = GetWsiMultiShotScheduleResult(nModuleIdx);
	if (pScheduleResult == NULL) return NULL;
	return pScheduleResult->GetPathSchedulerResult(nResultIdx);
}

const SSchedulerResult* CGlassResult::GetWsiMultiShotSSchedulerResult(int nModuleIdx, int nResultIdx) const
{
	const CPathSchedulerResult* pScheduleResult = GetWsiMultiShotScheduleResult(nModuleIdx);
	if (pScheduleResult == NULL) return NULL;
	return pScheduleResult->GetPathSchedulerResult(nResultIdx);
}



void CGlassResult::AddWsiUserScheduleRedult( const CPathSchedulerResult& scheduleResult )
{
	m_vecWsiUserScheduleResult.push_back(scheduleResult);
}

BOOL CGlassResult::AddDefectResult(CDefectResult* pDefectResult)
{
	EnterCriticalSection(&m_csDefect);
	if (!pDefectResult)
	{
		LeaveCriticalSection(&m_csDefect);
		return FALSE;
	}

	if (pDefectResult)
	{
		pDefectResult->nDefectIdx = m_nCurDefectIdx;
		m_mapDefectResult.insert(std::make_pair(pDefectResult->nUMOriginX, pDefectResult));
		m_nCurDefectIdx++;

		ClassifyDefectResult(pDefectResult);
	}
	LeaveCriticalSection(&m_csDefect);
	return TRUE;
}

void CGlassResult::ClassifyDefectResult(CDefectResult* pDefectResult)
{
	if(pDefectResult->nLocation == DefectLoc_Crack)
	{
		m_vecCrackDefectResult.push_back(*pDefectResult);
	}
	else if(pDefectResult->nLocation == DefectLoc_ASG ||
			pDefectResult->nLocation == DefectLoc_PAD ||
			pDefectResult->nLocation == DefectLoc_C2C)
	{
		m_vecPadDefectResult.push_back(*pDefectResult);
	}
	else if(pDefectResult->nLocation == DefectLoc_Align)
	{
		m_vecAlignDefectResult.push_back(*pDefectResult);
	}
	//subtype
	else if(pDefectResult->nSubType == DefectSubType_MC ||
			pDefectResult->nSubType == DefectSubType_Mask)
	{
		m_vecMaskDefectResult.push_back(*pDefectResult);
	}
	else if(pDefectResult->nSubType == DefectSubType_Common)
	{
		m_vecCommonDefectResult.push_back(*pDefectResult);
	}
	else
	{
		m_vecActiveDefectResult.push_back(*pDefectResult);
	}

	//rework, À§ ÄÚµå¿Í Áߺ¹°¡´ÉÇÔ.
	if(pDefectResult->bRework)
	{
		m_vecReworkDefectResult.push_back(*pDefectResult);
	}
}


BOOL CGlassResult::CheckReviewComplete(int nModuleIdx)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bRet = TRUE;
	if (nModuleIdx==-1)
	{
		for (constVectorReviewResultIt it=m_vecReviewResult.begin(); it!=m_vecReviewResult.end(); it++)
		{
			// Á¶°Ç¹® ¼öÁ¤ [6/20/2017 bhs]
			//bRet = bRet && it->CheckComplete();
			bRet &= it->CheckComplete();

			if (bRet==FALSE) break;
		}
	}
	else
	{
		bRet = FALSE;
		CReviewResult *pReviewResult = GetReviewResult(nModuleIdx);
		if (pReviewResult)
		{
			bRet = pReviewResult->CheckComplete();
		}
	}

	LeaveCriticalSection(&m_csProcess);

	return bRet;
}

BOOL CGlassResult::CheckUserComplete(int nModuleIdx)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bRet = TRUE;
	if (nModuleIdx==-1)
	{
		for (constVectorReviewResultIt it=m_vecUserResult.begin(); it!=m_vecUserResult.end(); it++)
		{
			// Á¶°Ç¹® ¼öÁ¤ [6/20/2017 bhss]
			//bRet = bRet && it->CheckComplete();
			bRet &= it->CheckComplete();

			if (bRet==FALSE) break;
		}
	}
	else
	{
		bRet = FALSE;
		CReviewResult *pReviewResult = GetUserResult(nModuleIdx);
		if (pReviewResult)
		{
			bRet = pReviewResult->CheckComplete();
		}
	}

	LeaveCriticalSection(&m_csProcess);

	return bRet;

}

BOOL CGlassResult::CheckWsiComplete(int nModuleIdx)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bRet = TRUE;
	if (nModuleIdx==-1)
	{
		for (constVectorReviewResultIt it=m_vecWsiResult.begin(); it!=m_vecWsiResult.end(); it++)
		{
			// Á¶°Ç¹® ¼öÁ¤ [6/20/2017 bhss]
			//bRet = bRet && it->CheckComplete();
			bRet &= it->CheckComplete();

			if (bRet==FALSE) break;
		}
	}
	else
	{
		bRet = FALSE;
		CReviewResult *pWsiResult = GetWsiResult(nModuleIdx);
		if (pWsiResult)
		{
			bRet = pWsiResult->CheckComplete();
		}
	}

	LeaveCriticalSection(&m_csProcess);

	return bRet;
}

BOOL CGlassResult::CheckMeasureComplete(int nModuleIdx)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bRet = TRUE;
	if (nModuleIdx==-1)
	{
		for (constVectorReviewResultIt it=m_vecMeasureResult.begin(); it!=m_vecMeasureResult.end(); it++)
		{
			// Á¶°Ç¹® ¼öÁ¤ [6/20/2017 bhss]
			//bRet = bRet && it->CheckComplete();
			bRet &= it->CheckComplete();

			if (bRet==FALSE) break;
		}
	}
	else
	{
		bRet = FALSE;
		CReviewResult *pMeasureResult = GetMeasureResult(nModuleIdx);
		if (pMeasureResult)
		{
			bRet = pMeasureResult->CheckComplete();
		}
	}

	LeaveCriticalSection(&m_csProcess);

	return bRet;
}

BOOL CGlassResult::CheckReflowComplete( int nModuleIdx/*=-1*/ )
{
	EnterCriticalSection(&m_csProcess);

	BOOL bRet = TRUE;
	if (nModuleIdx==-1)
	{
		for (constVectorReviewResultIt it=m_vecReflowResult.begin(); it!=m_vecReflowResult.end(); it++)
		{
			bRet &= it->CheckComplete();

			if (bRet==FALSE) break;
		}
	}
	else
	{
		bRet = FALSE;
		CReviewResult *pReviewResult = GetReflowResult(nModuleIdx);
		if (pReviewResult)
		{
			bRet = pReviewResult->CheckComplete();
		}
	}

	LeaveCriticalSection(&m_csProcess);

	return bRet;
}

BOOL CGlassResult::CheckWsiReflowComplete(int nModuleIdx)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bRet = TRUE;
	if (nModuleIdx==-1)
	{
		for (constVectorReviewResultIt it=m_vecWsiReflowResult.begin(); it!=m_vecWsiReflowResult.end(); it++)
		{
			// Á¶°Ç¹® ¼öÁ¤ [6/20/2017 bhss]
			//bRet = bRet && it->CheckComplete();
			bRet &= it->CheckComplete();

			if (bRet==FALSE) break;
		}
	}
	else
	{
		bRet = FALSE;
		CReviewResult *pWsiResult = GetWsiReflowResult(nModuleIdx);
		if (pWsiResult)
		{
			bRet = pWsiResult->CheckComplete();
		}
	}

	LeaveCriticalSection(&m_csProcess);

	return bRet;
}

BOOL CGlassResult::SetReviewResultData(int nModuleIdx, int nResultIdx, VectorImageData& vectorImageData, int nGlassPosX, int nGlassPosY, int nMotorPosX, int nMotorPosY, double dDurationTime)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bReturn = FALSE;
	SReviewResult *pSReviewResult = GetSReviewResult(nModuleIdx, nResultIdx);
	if (pSReviewResult)
	{
		pSReviewResult->nResultCode		= ReviewResult_Snap_Complete;
		pSReviewResult->nUMGrabPosX		= nGlassPosX;
		pSReviewResult->nUMGrabPosY		= nGlassPosY;
		pSReviewResult->dDurationTime	= dDurationTime;
		pSReviewResult->vectorImageData	= vectorImageData;

		//Modify by Juneki 2016-03-23
		for(int i=0;i<vectorImageData.size();i++)
		{
			if(i>=MAX_IMAGEDATA)
				break;

			pSReviewResult->vectorImageData[i]= vectorImageData[i];
		}

		bReturn = TRUE;
	}

	LeaveCriticalSection(&m_csProcess);

	return bReturn;
}


BOOL CGlassResult::SetUserResultData(int nModuleIdx, int nResultIdx, VectorImageData& vectorImageData, int nGlassPosX, int nGlassPosY, int nMotorPosX, int nMotorPosY, double dDurationTime)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bReturn = FALSE;
	SReviewResult *pSReviewResult = GetSUserResult(nModuleIdx, nResultIdx);
	if (pSReviewResult)
	{
		pSReviewResult->nResultCode		= ReviewResult_Snap_Complete;
		pSReviewResult->nUMGrabPosX		= nGlassPosX;
		pSReviewResult->nUMGrabPosY		= nGlassPosY;
		pSReviewResult->dDurationTime	= dDurationTime;
		//pSReviewResult->vectorImageData	= vectorImageData;

		//Modify by Juneki 2016-03-23
		for(int i=0;i<vectorImageData.size();i++)
		{
			if(i>=MAX_IMAGEDATA)
				break;

			pSReviewResult->vectorImageData[i]= vectorImageData[i];
		}

		bReturn = TRUE;
	}

	LeaveCriticalSection(&m_csProcess);

	return bReturn;
}


BOOL CGlassResult::SetMeasureResultData(int nModuleIdx, int nResultIdx, VectorImageData& vectorImageData, int nGlassPosX, int nGlassPosY, int nMotorPosX, int nMotorPosY, double dDurationTime)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bReturn = FALSE;
	SReviewResult *pSReviewResult = GetSMeasureResult(nModuleIdx, nResultIdx);
	if (pSReviewResult)
	{
		pSReviewResult->nResultCode		= ReviewResult_Snap_Complete;
		pSReviewResult->nUMGrabPosX		= nGlassPosX;
		pSReviewResult->nUMGrabPosY		= nGlassPosY;
		pSReviewResult->dDurationTime	= dDurationTime;
		//pSReviewResult->vectorImageData	= vectorImageData;

		//Modify by Juneki 2016-03-23
		for(int i=0;i<vectorImageData.size();i++)
		{
			if(i>=MAX_IMAGEDATA)
				break;

			pSReviewResult->vectorImageData[i]= vectorImageData[i];
		}

		bReturn = TRUE;
	}

	LeaveCriticalSection(&m_csProcess);

	return bReturn;
}

BOOL CGlassResult::SetWsiResultData(int nModuleIdx, int nResultIdx, const SReviewResult& wsiResult, int nGlassPosX, int nGlassPosY, int nMotorPosX, int nMotorPosY, double dDurationTime)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bReturn = FALSE;
	SReviewResult* pSWsiResult = GetSWsiResult(nModuleIdx, nResultIdx);
	if (pSWsiResult)
	{
		// nWsi_ResultCode ´©¶ô ¼öÁ¤ [6/20/2017 bhs]
		pSWsiResult->nWsi_ResultCode		= wsiResult.nWsi_ResultCode;
		pSWsiResult->nWsi_Type				= wsiResult.nWsi_Type;
		pSWsiResult->nWsi_SlopeWarn			= wsiResult.nWsi_SlopeWarn;
		pSWsiResult->bBigSizeDefect = wsiResult.bBigSizeDefect;

		switch (wsiResult.nGlassType)
		{

		case 0://TFE
			pSWsiResult->nWsi_Type = wsiResult.nWsi_Type;
			pSWsiResult->bBigSizeDefect = wsiResult.bBigSizeDefect;
			pSWsiResult->fHeight = wsiResult.fHeight;
			pSWsiResult->fWidthX = wsiResult.fWidthX;
			pSWsiResult->fWidthY = wsiResult.fWidthY;
			pSWsiResult->fAratio = wsiResult.fAratio;
			break;
		case 1: //MN
			pSWsiResult->nDecisionZoneA = wsiResult.nDecisionZoneA;
			pSWsiResult->nDecisionZoneB = wsiResult.nDecisionZoneB;
			pSWsiResult->nDecisionZoneC = wsiResult.nDecisionZoneC;
			pSWsiResult->nDecisionZoneD = wsiResult.nDecisionZoneD;
			pSWsiResult->nDecisionZoneE = wsiResult.nDecisionZoneE;
			pSWsiResult->nDecisionZoneF = wsiResult.nDecisionZoneF;
			pSWsiResult->nPointIndex = wsiResult.nPointIndex;
			pSWsiResult->nDecisionZoneSlotB = wsiResult.nDecisionZoneSlotB;
			pSWsiResult->dDistFromRef = wsiResult.dDistFromRef;
			break;
		case 2: //QD
			pSWsiResult->nJugementR = wsiResult.nJugementR;
			pSWsiResult->nJugementG = wsiResult.nJugementG;
			pSWsiResult->nJugementB = wsiResult.nJugementB;
			pSWsiResult->dRZoneHeight = wsiResult.dRZoneHeight;
			pSWsiResult->dGZoneHeight = wsiResult.dGZoneHeight;
			pSWsiResult->dBZoneHeight = wsiResult.dBZoneHeight;
			pSWsiResult->dDefectHeight = wsiResult.dDefectHeight;
			pSWsiResult->nWsi_DefectType = wsiResult.nDefectType;
			// 		wsiResult.Ãß°¡ Çϼ¼¿ä= measureResut.nMultiShot;
			// 		wsiResult.Ãß°¡ Çϼ¼¿ä= measureResut.nCurrentShotNumber;
			break;
		case 3: //BANK
			pSWsiResult->dRZoneHeight = wsiResult.dRZoneHeight;
			pSWsiResult->dGZoneHeight = wsiResult.dGZoneHeight;
			pSWsiResult->dBZoneHeight = wsiResult.dBZoneHeight;
			pSWsiResult->dDefectHeight = wsiResult.dDefectHeight;
			pSWsiResult->nWsi_DefectType = wsiResult.nDefectType;
			// 		wsiResult.Ãß°¡ Çϼ¼¿ä= measureResut.nMultiShot;
			// 		wsiResult.Ãß°¡ Çϼ¼¿ä= measureResut.nCurrentShotNumber;
			break;
		case 4: //CS
			pSWsiResult->dCSHeight = wsiResult.dCSHeight;
			pSWsiResult->dDefectHeight = wsiResult.dDefectHeight;
			pSWsiResult->nWsi_DefectType = wsiResult.nDefectType;
			// 		wsiResult.Ãß°¡ Çϼ¼¿ä= measureResut.nMultiShot;
			break;
		}

		memcpy(pSWsiResult->pWsi_ResultData, wsiResult.pWsi_ResultData, sizeof(wsiResult.pWsi_ResultData));

		// bug fix [6/20/2017 bhs]
		//if (wsiResult.nResultCode==1)
		if (pSWsiResult->nWsi_ResultCode == 1)
		{
			pSWsiResult->nResultCode = WsiResultSuccess;
		}
		else
		{
			pSWsiResult->nResultCode = WsiResult_Fail;
		}

		bReturn = TRUE;
	}

	LeaveCriticalSection(&m_csProcess);

	return bReturn;
}

BOOL CGlassResult::SetReflowResultData(int nModuleIdx, int nResultIdx, VectorImageData& vectorImageData, int nGlassPosX, int nGlassPosY, int nMotorPosX, int nMotorPosY, double dDurationTime)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bReturn = FALSE;
	SReviewResult *pSReviewResult = GetSReflowResult(nModuleIdx, nResultIdx);
	if (pSReviewResult)
	{
		pSReviewResult->nResultCode		= ReviewResult_Snap_Complete;
		pSReviewResult->nUMGrabPosX		= nGlassPosX;
		pSReviewResult->nUMGrabPosY		= nGlassPosY;
		pSReviewResult->dDurationTime	= dDurationTime;
		//pSReviewResult->vectorImageData	= vectorImageData;

		//Modify by Juneki 2016-03-23
		for(int i=0;i<vectorImageData.size();i++)
		{
			if(i>=MAX_IMAGEDATA)
				break;

			pSReviewResult->vectorImageData[i]= vectorImageData[i];
		}

		bReturn = TRUE;
	}

	LeaveCriticalSection(&m_csProcess);

	return bReturn;
}

void CGlassResult::SetGlassSize(int nGlassSizeX, int nGlassSizeY)
{
	m_nGlassSizeX = nGlassSizeX;
	m_nGlassSizeY = nGlassSizeY;
}

void CGlassResult::GetGlassSize(int& nGlassSizeX, int& nGlassSizeY)
{
	nGlassSizeX = m_nGlassSizeX;
	nGlassSizeY = m_nGlassSizeY;
}

void CGlassResult::SetGlassOriginDirection(int nGlassOriginDirection)
{
	m_nOriginDir = nGlassOriginDirection;
}

void CGlassResult::SetCornerCutDirection(int nCornerCutDirection)
{
	m_nCornerCutDir = nCornerCutDirection;
}

void CGlassResult::SetGlassCenterCoordinate(BOOL bCenter)
{
	m_bCenterCoordinate = bCenter;
}

void CGlassResult::SetGlassInverseCoordinate(BOOL bInverse)
{
	m_bInverseCoordinate = bInverse;
}

// review result
CReviewResult* CGlassResult::GetReviewResult(int nModuleIdx)					
{ 
	for (VectorReviewResultIt it=m_vecReviewResult.begin(); it!=m_vecReviewResult.end(); it++)
	{
		if (nModuleIdx==it->GetModuleIndex())
		{
			return static_cast<CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

const CReviewResult* CGlassResult::GetReviewResult(int nModuleIdx) const				
{ 
	for (constVectorReviewResultIt it=m_vecReviewResult.begin(); it!=m_vecReviewResult.end(); it++)
	{
		if (nModuleIdx==it->GetModuleIndex())
		{
			return static_cast<const CReviewResult*>(&(*it));
		}
	}
	return NULL;
}


int	CGlassResult::GetTotalSReviewResultCount() const
{
	int nTotalCount = 0;
	int nModuleIdx = 0, nMIdx2 = 0;
	for (nModuleIdx=0, nMIdx2=0; nModuleIdx<GetReviewResultCount(); nModuleIdx++, nMIdx2++)
	{
		
		const CReviewResult *pNode = GetReviewResult(nMIdx2);
		if (pNode==NULL) 
		{
			nModuleIdx--;
			continue;
		}

		nTotalCount += pNode->GetSReviewResultCount();
	}
	return nTotalCount;
}

int	CGlassResult::GetSReviewResultCount(int nModuleIdx) const		
{ 
	const CReviewResult* pReviewResult = GetReviewResult(nModuleIdx);
	if (pReviewResult==NULL) return -1;

	return pReviewResult->GetSReviewResultCount();
}

SReviewResult* CGlassResult::GetSReviewResult(int nModuleIdx, int nResultIdx)		
{
	CReviewResult* pReviewResult = GetReviewResult(nModuleIdx);
	if (pReviewResult==NULL) return NULL;

	return pReviewResult->GetSReviewResult(nResultIdx);
}

const SReviewResult* CGlassResult::GetSReviewResult(int nModuleIdx, int nResultIdx) const
{
	const CReviewResult* pReviewResult = GetReviewResult(nModuleIdx);
	if (pReviewResult==NULL) return NULL;

	return pReviewResult->GetSReviewResult(nResultIdx);
}

void CGlassResult::AddReviewResult(const CReviewResult& cReviewResult)
{
	m_vecReviewResult.push_back(cReviewResult);
}

void CGlassResult::AddSReviewResult(int nModuleIdx, const SReviewResult& sReviewResult)
{

	CReviewResult* pReviewResult = GetReviewResult(nModuleIdx);
	if (pReviewResult==NULL) return ;
	pReviewResult->AddSReviewResult(sReviewResult);
}

// user result
CReviewResult* CGlassResult::GetUserResult(int nModuleIdx)					
{ 
	for (VectorReviewResultIt it=m_vecUserResult.begin(); it!=m_vecUserResult.end(); it++)
	{
		if (nModuleIdx==it->GetModuleIndex())
		{
			return static_cast<CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

const CReviewResult* CGlassResult::GetUserResult(int nModuleIdx) const				
{ 
	for (constVectorReviewResultIt it=m_vecUserResult.begin(); it!=m_vecUserResult.end(); it++)
	{
		if (nModuleIdx==it->GetModuleIndex())
		{
			return static_cast<const CReviewResult*>(&(*it));
		}
	}
	return NULL;
}


int	CGlassResult::GetTotalSUserResultCount() const
{
	int nTotalCount = 0;
	int nModuleIdx = 0, nMIdx2 = 0;
	for (nModuleIdx=0, nMIdx2 = 0; nModuleIdx<GetUserResultCount(); nModuleIdx++,nMIdx2++)
	{
		const CReviewResult *pNode = GetUserResult(nMIdx2);
		if (pNode==NULL) 
		{
			nModuleIdx--;
			continue;
		}

		nTotalCount += pNode->GetSReviewResultCount();
	}
	return nTotalCount;
}

int	CGlassResult::GetSUserResultCount(int nModuleIdx) const		
{ 
	const CReviewResult* pReviewResult = GetUserResult(nModuleIdx);
	if (pReviewResult==NULL) return -1;

	return pReviewResult->GetSReviewResultCount();
}

int	CGlassResult::GetSUserCompleteResultCount(int nModuleIdx, int resultCode) const		
{ 
	const CReviewResult* pReviewResult = GetUserResult(nModuleIdx);
	if (pReviewResult==NULL) return -1;

	return pReviewResult->GetSReviewResultCount(resultCode);
}

SReviewResult* CGlassResult::GetSUserResult(int nModuleIdx, int nResultIdx)		
{
	CReviewResult* pReviewResult = GetUserResult(nModuleIdx);
	if (pReviewResult==NULL) return NULL;

	return pReviewResult->GetSReviewResult(nResultIdx);
}

const SReviewResult* CGlassResult::GetSUserResult(int nModuleIdx, int nResultIdx) const
{
	const CReviewResult* pReviewResult = GetUserResult(nModuleIdx);
	if (pReviewResult==NULL) return NULL;

	return pReviewResult->GetSReviewResult(nResultIdx);
}

void CGlassResult::AddUserResult(const CReviewResult& cReviewResult)
{
	m_vecUserResult.push_back(cReviewResult);
}

void CGlassResult::AddSUserResult(int nModuleIdx, const SReviewResult& sReviewResult)
{
	CReviewResult* pReviewResult = GetUserResult(nModuleIdx);
	if (pReviewResult==NULL) return ;
	pReviewResult->AddSReviewResult(sReviewResult);
}

// wsi result
CReviewResult*	CGlassResult::GetWsiResult(int nModuleIdx)
{
	for (VectorReviewResultIt it=m_vecWsiResult.begin(); it!=m_vecWsiResult.end(); it++)
	{
		if (nModuleIdx==it->GetModuleIndex())
		{
			return static_cast<CReviewResult*>(&(*it));
		}
	}
	return NULL;
}


const CReviewResult* CGlassResult::GetWsiResult(int nModuleIdx) const
{
	for (constVectorReviewResultIt it=m_vecWsiResult.begin(); it!=m_vecWsiResult.end(); it++)
	{
		if (nModuleIdx==it->GetModuleIndex())
		{
			return static_cast<const CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

int	CGlassResult::GetTotalSWsiResultCount() const
{
	int nTotalCount = 0;
	for (int nModuleIdx=0; nModuleIdx<GetWsiResultCount(); nModuleIdx++)
	{
		const CReviewResult *pNode = GetWsiResult(nModuleIdx);
		if (pNode==NULL) continue;

		nTotalCount += pNode->GetSReviewResultCount();
	}
	return nTotalCount;
}

int	CGlassResult::GetSWsiResultCount(int nModuleIdx) const
{
	const CReviewResult* pWsiResult = GetWsiResult(nModuleIdx);
	if (pWsiResult==NULL) return -1;
	return pWsiResult->GetSReviewResultCount();
}

SReviewResult*	CGlassResult::GetSWsiResult(int nModuleIdx, int nResultIdx)
{
	CReviewResult* pWsiResult = GetWsiResult(nModuleIdx);
	if (pWsiResult==NULL) return NULL;
	return pWsiResult->GetSReviewResult(nResultIdx);
}

const SReviewResult* CGlassResult::GetSWsiResult(int nModuleIdx, int nResultIdx) const
{
	for (constVectorReviewResultIt it=m_vecWsiResult.begin(); it!=m_vecWsiResult.end(); it++)
	{
		if (nModuleIdx==it->GetModuleIndex())
		{			
			return it->GetSReviewResult(nResultIdx);
		}
	}
	return NULL;
}

void CGlassResult::AddWsiResult(const CReviewResult& cReviewResult)
{
	m_vecWsiResult.push_back(cReviewResult);
}

void CGlassResult::AddSWsiResult(int nModuleIdx, const SReviewResult& sReviewResult)
{
	CReviewResult* pWsiResult = GetWsiResult(nModuleIdx);
	if (pWsiResult==NULL) return ;

	pWsiResult->AddSReviewResult(sReviewResult);
}


CReviewResult* CGlassResult::GetWsiMultiShotResult(int nModuleIdx)
{
	for (VectorReviewResultIt it = m_vecWsiMultiShotResult.begin(); it != m_vecWsiMultiShotResult.end(); it++)
	{
		if (nModuleIdx == it->GetModuleIndex())
		{
			return static_cast<CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

const CReviewResult* CGlassResult::GetWsiMultiShotResult(int nModuleIdx) const
{
	for (constVectorReviewResultIt it = m_vecWsiMultiShotResult.begin(); it != m_vecWsiMultiShotResult.end(); it++)
	{
		if (nModuleIdx == it->GetModuleIndex())
		{
			return static_cast<const CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

int CGlassResult::GetTotalSWsiMultiShotResultCount() const
{
	int nTotalCount = 0;
	for (int nModuleIdx = 0; nModuleIdx < GetWsiMultiShotResultCount(); nModuleIdx++)
	{
		const CReviewResult *pNode = GetWsiMultiShotResult(nModuleIdx);
		if (pNode == NULL) continue;

		nTotalCount += pNode->GetSReviewResultCount();
	}
	return nTotalCount;
}

int CGlassResult::GetSWsiMultiShotResultCount(int nModuleIdx) const
{
	const CReviewResult* pWsiMultiShotResult = GetWsiMultiShotResult(nModuleIdx);
	if (pWsiMultiShotResult == NULL) return -1;
	return pWsiMultiShotResult->GetSReviewResultCount();
}

SReviewResult* CGlassResult::GetSWsiMultiShotResult(int nModuleIdx, int nResultIdx)
{
	CReviewResult* pWsiMultiShotResult = GetWsiMultiShotResult(nModuleIdx);
	if (pWsiMultiShotResult == NULL) return NULL;
	return pWsiMultiShotResult->GetSReviewResult(nResultIdx);
}

const SReviewResult* CGlassResult::GetSWsiMultiShotResult(int nModuleIdx, int nResultIdx) const
{
	for (constVectorReviewResultIt it = m_vecWsiMultiShotResult.begin(); it != m_vecWsiMultiShotResult.end(); it++)
	{
		if (nModuleIdx == it->GetModuleIndex())
		{
			return it->GetSReviewResult(nResultIdx);
		}
	}
	return NULL;
}

void CGlassResult::AddWsiMultiShotResult(const CReviewResult& cReviewResult)
{
	m_vecWsiMultiShotResult.push_back(cReviewResult);
}

void CGlassResult::AddSWSIMultiShotResult(int nModuleIdx, const SReviewResult& sReviewResult)
{
	CReviewResult* pWsiMultiShotResult = GetWsiResult(nModuleIdx);
	if (pWsiMultiShotResult == NULL) return;

	pWsiMultiShotResult->AddSReviewResult(sReviewResult);
}

// measure result
CReviewResult* CGlassResult::GetMeasureResult(int nModuleIdx)
{
	for(VectorReviewResultIt it = m_vecMeasureResult.begin(); it != m_vecMeasureResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

const CReviewResult* CGlassResult::GetMeasureResult(int nModuleIdx) const
{
	for(constVectorReviewResultIt it = m_vecMeasureResult.begin(); it != m_vecMeasureResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

int	CGlassResult::GetTotalSMeasureResultCount() const
{
	int nTotalCount = 0;
	for (int nModuleIdx=0; nModuleIdx<GetMeasureResultCount(); nModuleIdx++)
	{
		const CReviewResult *pNode = GetMeasureResult(nModuleIdx);
		if (pNode==NULL) continue;

		nTotalCount += pNode->GetSReviewResultCount();
	}
	return nTotalCount;
}

int	CGlassResult::GetSMeasureResultCount(int nModuleIdx) const
{
	const CReviewResult* pMeasureResult = GetMeasureResult(nModuleIdx);
	if(pMeasureResult == NULL) return -1;
	return pMeasureResult->GetSReviewResultCount();
}

SReviewResult* CGlassResult::GetSMeasureResult(int nModuleIdx, int nResultIdx)
{
	CReviewResult* pMeasureResult = GetMeasureResult(nModuleIdx);
	if(pMeasureResult == NULL) return NULL;
	return pMeasureResult->GetSReviewResult(nResultIdx);
}

const SReviewResult* CGlassResult::GetSMeasureResult(int nModuleIdx, int nResultIdx) const
{
	const CReviewResult* pMeasureResult = GetMeasureResult(nModuleIdx);
	if(pMeasureResult == NULL) return NULL;
	return pMeasureResult->GetSReviewResult(nResultIdx);
}

void CGlassResult::AddMeasureResult(const CReviewResult& cReviewResult)
{
	m_vecMeasureResult.push_back(cReviewResult);
}
void CGlassResult::AddSMeasureResult(int nModuleIdx, const SReviewResult& sReviewResult)
{
	CReviewResult* pMeasureResult = GetMeasureResult(nModuleIdx);
	if(pMeasureResult == NULL) return;
	pMeasureResult->AddSReviewResult(sReviewResult);
}

// reflow result
CReviewResult* CGlassResult::GetReflowResult( int nModuleIdx )
{
	for(VectorReviewResultIt it = m_vecReflowResult.begin(); it != m_vecReflowResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

const CReviewResult* CGlassResult::GetReflowResult( int nModuleIdx ) const
{
	for(constVectorReviewResultIt it = m_vecReflowResult.begin(); it != m_vecReflowResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

int CGlassResult::GetTotalSReflowResultCount() const
{
	int nTotalCount = 0;
	for (int nModuleIdx=0; nModuleIdx<GetReflowResultCount(); nModuleIdx++)
	{
		const CReviewResult *pNode = GetReflowResult(nModuleIdx);
		if (pNode==NULL) continue;

		nTotalCount += pNode->GetSReviewResultCount();
	}
	return nTotalCount;
}

int CGlassResult::GetSReflowResultCount( int nModuleIdx ) const
{
	const CReviewResult* pResult = GetReflowResult(nModuleIdx);
	if(pResult == NULL) return -1;
	return pResult->GetSReviewResultCount(ReviewResult_Process_Complete);
}

SReviewResult* CGlassResult::GetSReflowResult( int nModuleIdx, int nResultIdx )
{
	CReviewResult* pResult = GetReflowResult(nModuleIdx);
	if(pResult == NULL) return NULL;
	return pResult->GetSReviewResult(nResultIdx);
}

const SReviewResult* CGlassResult::GetSReflowResult( int nModuleIdx, int nResultIdx ) const
{
	const CReviewResult* pResult = GetReflowResult(nModuleIdx);
	if(pResult == NULL) return NULL;
	return pResult->GetSReviewResult(nResultIdx);
}

void CGlassResult::AddReflowResult( const CReviewResult& cReviewResult )
{
	m_vecReflowResult.push_back(cReviewResult);
}

void CGlassResult::AddSReflowResult( int nModuleIdx, const SReviewResult& sReviewResult )
{
	CReviewResult* pResult = GetReflowResult(nModuleIdx);
	if(pResult == NULL) return;
	pResult->AddSReviewResult(sReviewResult);
}

// wsi user result
CReviewResult* CGlassResult::GetWsiUserResult( int nModuleIdx )
{
	for(VectorReviewResultIt it = m_vecWsiUserResult.begin(); it != m_vecWsiUserResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

CReviewResult* CGlassResult::GetWsiReflowResult( int nModuleIdx )
{
	for(VectorReviewResultIt it = m_vecWsiReflowResult.begin(); it != m_vecWsiReflowResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

const CReviewResult* CGlassResult::GetWsiReflowResult( int nModuleIdx ) const
{
	for(constVectorReviewResultIt it = m_vecWsiReflowResult.begin(); it != m_vecWsiReflowResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CReviewResult*>(&(*it));
		}
	}
	return NULL;
}


const CReviewResult* CGlassResult::GetWsiUserResult( int nModuleIdx ) const
{
	for(constVectorReviewResultIt it = m_vecWsiUserResult.begin(); it != m_vecWsiUserResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CReviewResult*>(&(*it));
		}
	}
	return NULL;
}

int CGlassResult::GetTotalSWsiReflowResultCount() const
{
	int nTotalCount = 0;
	for (int nModuleIdx=0; nModuleIdx<GetWsiReflowResultCount(); nModuleIdx++)
	{
		const CReviewResult *pNode = GetWsiReflowResult(nModuleIdx);
		if (pNode==NULL) continue;

		nTotalCount += pNode->GetSReviewResultCount();
	}
	return nTotalCount;
}

int CGlassResult::GetTotalSWsiUserResultCount() const
{
	int nTotalCount = 0;
	for (int nModuleIdx=0; nModuleIdx<GetWsiUserResultCount(); nModuleIdx++)
	{
		const CReviewResult *pNode = GetWsiUserResult(nModuleIdx);
		if (pNode==NULL) continue;

		nTotalCount += pNode->GetSReviewResultCount();
	}
	return nTotalCount;
}

int CGlassResult::GetSWsiReflowResultCount( int nModuleIdx ) const
{
	const CReviewResult* pResult = GetWsiReflowResult(nModuleIdx);
	if(pResult == NULL) return -1;
	return pResult->GetSReviewResultCount(ReviewResult_Process_Complete);
}

SReviewResult* CGlassResult::GetSWsiReflowResult( int nModuleIdx, int nResultIdx )
{
	CReviewResult* pResult = GetWsiReflowResult(nModuleIdx);
	if(pResult == NULL) return NULL;
	return pResult->GetSReviewResult(nResultIdx);
}

const SReviewResult* CGlassResult::GetSWsiReflowResult( int nModuleIdx, int nResultIdx ) const
{
	const CReviewResult* pResult = GetWsiReflowResult(nModuleIdx);
	if(pResult == NULL) return NULL;
	return pResult->GetSReviewResult(nResultIdx);
}

void CGlassResult::AddWsiReflowResult( const CReviewResult& cReviewResult )
{
	m_vecWsiReflowResult.push_back(cReviewResult);
}

const VectorReviewResult* CGlassResult::GetVectorUserWsiResult() const
{
	return &m_vecWsiUserResult;
}

VectorReviewResult* CGlassResult::GetVectorUserWsiResult()
{
	return &m_vecWsiUserResult;
}

void CGlassResult::AddWsiUserResult( const CReviewResult& cReviewResult )
{
	m_vecWsiUserResult.push_back(cReviewResult);
}


void CGlassResult::AddSWsiReflowResult( int nModuleIdx, const SReviewResult& sReviewResult )
{
	CReviewResult* pResult = GetWsiReflowResult(nModuleIdx);
	if(pResult == NULL) return;
	pResult->AddSReviewResult(sReviewResult);
}

// review schedule result
CPathSchedulerResult* CGlassResult::GetReviewScheduleResult(int nModuleIdx)
{
	for(VectorReviewScheduleResultIt it = m_vecReviewScheduleResult.begin(); it != m_vecReviewScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

const CPathSchedulerResult* CGlassResult::GetReviewScheduleResult(int nModuleIdx) const
{	
	for(constVectorReviewScheduleResultIt it = m_vecReviewScheduleResult.begin(); it != m_vecReviewScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;	
}

int	CGlassResult::GetReviewSSchedulerResultCount(int nModuleIdx) const
{
	const CPathSchedulerResult* pReviewScheduleResult = GetReviewScheduleResult(nModuleIdx);
	if(pReviewScheduleResult == NULL) return -1;
	return pReviewScheduleResult->GetPathSchedulerResultCount();
}

SSchedulerResult* CGlassResult::GetReviewSSchedulerResult(int nModuleIdx, int nResultIdx)
{
	for(VectorReviewScheduleResultIt it = m_vecReviewScheduleResult.begin(); it != m_vecReviewScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return it->GetPathSchedulerResult(nResultIdx);
		}
	}
	return NULL; 
}

const SSchedulerResult* CGlassResult::GetReviewSSchedulerResult(int nModuleIdx, int nResultIdx) const
{
	for(constVectorReviewScheduleResultIt it = m_vecReviewScheduleResult.begin(); it != m_vecReviewScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return it->GetPathSchedulerResult(nResultIdx);
		}
	}
	return NULL;
}

// user schedule result
CPathSchedulerResult* CGlassResult::GetUserScheduleResult(int nModuleIdx)
{
	for(VectorReviewScheduleResultIt it = m_vecUserScheduleResult.begin(); it != m_vecUserScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

const CPathSchedulerResult* CGlassResult::GetUserScheduleResult(int nModuleIdx) const
{	
	for(constVectorReviewScheduleResultIt it = m_vecUserScheduleResult.begin(); it != m_vecUserScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;	
}

int	CGlassResult::GetUserSSchedulerResultCount(int nModuleIdx) const
{
	const CPathSchedulerResult* pReviewScheduleResult = GetUserScheduleResult(nModuleIdx);
	if(pReviewScheduleResult == NULL) return -1;
	return pReviewScheduleResult->GetPathSchedulerResultCount();
}

SSchedulerResult* CGlassResult::GetUserSSchedulerResult(int nModuleIdx, int nResultIdx)
{
	for(VectorReviewScheduleResultIt it = m_vecUserScheduleResult.begin(); it != m_vecUserScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return it->GetPathSchedulerResult(nResultIdx);
		}
	}
	return NULL; 
}

const SSchedulerResult* CGlassResult::GetUserSSchedulerResult(int nModuleIdx, int nResultIdx) const
{
	for(constVectorReviewScheduleResultIt it = m_vecUserScheduleResult.begin(); it != m_vecUserScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return it->GetPathSchedulerResult(nResultIdx);
		}
	}
	return NULL;
}


// wsi schedule result
CPathSchedulerResult* CGlassResult::GetWsiScheduleResult(int nModuleIdx)
{
	for(VectorReviewScheduleResultIt it = m_vecWsiScheduleResult.begin(); it != m_vecWsiScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

const CPathSchedulerResult* CGlassResult::GetWsiScheduleResult(int nModuleIdx) const
{
	for(constVectorReviewScheduleResultIt it = m_vecWsiScheduleResult.begin(); it != m_vecWsiScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

int	CGlassResult::GetWsiSSchedulerResultCount(int nModuleIdx) const
{
	const CPathSchedulerResult* pWsiScheduleResult = GetWsiScheduleResult(nModuleIdx);
	if(pWsiScheduleResult == NULL) return -1;
	return pWsiScheduleResult->GetPathSchedulerResultCount();
}

SSchedulerResult* CGlassResult::GetWsiSSchedulerResult(int nModuleIdx, int nResultIdx)
{
	CPathSchedulerResult* pScheduleResult = GetWsiScheduleResult(nModuleIdx);
	if(pScheduleResult == NULL) return NULL;
	return pScheduleResult->GetPathSchedulerResult(nResultIdx);
}

const SSchedulerResult* CGlassResult::GetWsiSSchedulerResult(int nModuleIdx, int nResultIdx) const
{
	const CPathSchedulerResult* pScheduleResult = GetWsiScheduleResult(nModuleIdx);
	if(pScheduleResult == NULL) return NULL;
	return pScheduleResult->GetPathSchedulerResult(nResultIdx);
}

// measure schedule result
CPathSchedulerResult* CGlassResult::GetMeausreScheduleResult(int nModuleIdx)
{
	for(VectorReviewScheduleResultIt it = m_vecMeasureScheduleResult.begin(); it != m_vecMeasureScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}
const CPathSchedulerResult* CGlassResult::GetMeausreScheduleResult(int nModuleIdx) const
{
	for(constVectorReviewScheduleResultIt it = m_vecMeasureScheduleResult.begin(); it != m_vecMeasureScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}
int	CGlassResult::GetMeausreSSchedulerResultCount(int nModuleIdx) const
{
	const CPathSchedulerResult* pReviewScheduleResult = GetMeausreScheduleResult(nModuleIdx);
	if(pReviewScheduleResult == NULL) return -1;
	return pReviewScheduleResult->GetPathSchedulerResultCount();
}
SSchedulerResult*	CGlassResult::GetMeausreSSchedulerResult(int nModuleIdx, int nResultIdx)
{
	CPathSchedulerResult* pReviewScheduleResult = GetMeausreScheduleResult(nModuleIdx);
	if(pReviewScheduleResult == NULL) return NULL;
	return pReviewScheduleResult->GetPathSchedulerResult(nResultIdx);
}
const SSchedulerResult* CGlassResult::GetMeausreSSchedulerResult(int nModuleIdx, int nResultIdx) const
{
	const CPathSchedulerResult* pReviewScheduleResult = GetMeausreScheduleResult(nModuleIdx);
	if(pReviewScheduleResult == NULL) return NULL;
	return pReviewScheduleResult->GetPathSchedulerResult(nResultIdx);
}

// reflow schedule result
CPathSchedulerResult* CGlassResult::GetReflowScheduleResult( int nModuleIdx )
{
	for(VectorReviewScheduleResultIt it = m_vecReflowScheduleResult.begin(); it != m_vecReflowScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

const CPathSchedulerResult* CGlassResult::GetReflowScheduleResult( int nModuleIdx ) const
{
	for(constVectorReviewScheduleResultIt it = m_vecReflowScheduleResult.begin(); it != m_vecReflowScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

int CGlassResult::GetReflowSSchedulerResultCount( int nModuleIdx ) const
{
	const CPathSchedulerResult* pScheduleResult = GetReflowScheduleResult(nModuleIdx);
	if(pScheduleResult == NULL) return -1;
	return pScheduleResult->GetPathSchedulerResultCount();
}

SSchedulerResult* CGlassResult::GetReflowSSchedulerResult( int nModuleIdx, int nResultIdx )
{
	CPathSchedulerResult* pScheduleResult = GetReflowScheduleResult(nModuleIdx);
	if(pScheduleResult == NULL) return NULL;
	return pScheduleResult->GetPathSchedulerResult(nResultIdx);
}

const SSchedulerResult* CGlassResult::GetReflowSSchedulerResult( int nModuleIdx, int nResultIdx ) const
{
	const CPathSchedulerResult* pScheduleResult = GetReflowScheduleResult(nModuleIdx);
	if(pScheduleResult == NULL) return NULL;
	return pScheduleResult->GetPathSchedulerResult(nResultIdx);
}

// wsi reflow schedule result
CPathSchedulerResult* CGlassResult::GetWsiReflowScheduleResult( int nModuleIdx )
{
	for(VectorReviewScheduleResultIt it = m_vecWsiReflowScheduleResult.begin(); it != m_vecWsiReflowScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

const CPathSchedulerResult* CGlassResult::GetWsiReflowScheduleResult( int nModuleIdx ) const
{
	for(constVectorReviewScheduleResultIt it = m_vecWsiReflowScheduleResult.begin(); it != m_vecWsiReflowScheduleResult.end(); it++)
	{
		if(nModuleIdx == it->GetModuleIndex()) 
		{
			return static_cast<const CPathSchedulerResult*>(&(*it));
		}
	}
	return NULL;
}

int CGlassResult::GetWsiReflowSSchedulerResultCount( int nModuleIdx ) const
{
	const CPathSchedulerResult* pScheduleResult = GetWsiReflowScheduleResult(nModuleIdx);
	if(pScheduleResult == NULL) return -1;
	return pScheduleResult->GetPathSchedulerResultCount();
}

SSchedulerResult* CGlassResult::GetWsiReflowSSchedulerResult( int nModuleIdx, int nResultIdx )
{
	CPathSchedulerResult* pScheduleResult = GetWsiReflowScheduleResult(nModuleIdx);
	if(pScheduleResult == NULL) return NULL;
	return pScheduleResult->GetPathSchedulerResult(nResultIdx);
}

const SSchedulerResult* CGlassResult::GetWsiReflowSSchedulerResult( int nModuleIdx, int nResultIdx ) const
{
	const CPathSchedulerResult* pScheduleResult = GetWsiReflowScheduleResult(nModuleIdx);
	if(pScheduleResult == NULL) return NULL;
	return pScheduleResult->GetPathSchedulerResult(nResultIdx);
}

// review result
const VectorReviewResult*		CGlassResult::GetVectorReviewResult() const							
{ 
	return &m_vecReviewResult; 
}

VectorReviewResult*				CGlassResult::GetVectorReviewResult() 								
{ 
	return &m_vecReviewResult;
}

int								CGlassResult::GetReviewResultCount() const							
{ 
	return (int)m_vecReviewResult.size(); 
}

// user result
const VectorReviewResult*		CGlassResult::GetVectorUserResult() const							
{ 
	return &m_vecUserResult; 
}

VectorReviewResult*				CGlassResult::GetVectorUserResult() 								
{ 
	return &m_vecUserResult;
}

int								CGlassResult::GetUserResultCount() const							
{ 
	return (int)m_vecUserResult.size(); 
}


// wsi result
const VectorReviewResult*			CGlassResult::GetVectorWsiResult() const								
{ 
	return &m_vecWsiResult; 
}

VectorReviewResult*				CGlassResult::GetVectorWsiResult() 		
{ 
	return &m_vecWsiResult; 
}

int								CGlassResult::GetWsiResultCount() const					
{ 
	return (int)m_vecWsiResult.size();
}




// measure result
const VectorReviewResult*		CGlassResult::GetVectorMeasureResult() const		
{ 
	return &m_vecMeasureResult;
}

VectorReviewResult*				CGlassResult::GetVectorMeasureResult() 				
{ 
	return &m_vecMeasureResult; 
}

int								CGlassResult::GetMeasureResultCount() const		
{
	return (int)m_vecMeasureResult.size(); 
}

// reflow result
const VectorReviewResult* CGlassResult::GetVectorReflowResult() const
{
	return &m_vecReflowResult;
}

VectorReviewResult* CGlassResult::GetVectorReflowResult()
{
	return &m_vecReflowResult;
}

int CGlassResult::GetReflowResultCount() const
{
	return (int)m_vecReflowResult.size();
}

// wsi reflow result
const VectorReviewResult* CGlassResult::GetVectorWsiReflowResult() const
{
	return &m_vecWsiReflowResult;
}

VectorReviewResult* CGlassResult::GetVectorWsiReflowResult()
{
	return &m_vecWsiReflowResult;
}

int CGlassResult::GetWsiReflowResultCount() const
{
	return (int)m_vecWsiReflowResult.size();
}

int CGlassResult::GetWsiUserResultCount() const
{
	return (int)m_vecWsiUserResult.size();
}
//WSI MultilShot
const VectorReviewResult* CGlassResult::GetVectorWsiMultiShotResult() const
{
	return &m_vecWsiMultiShotResult;
}

VectorReviewResult* CGlassResult::GetVectorWsiMultiShotResult()
{
	return &m_vecWsiMultiShotResult;
}

int CGlassResult::GetWsiMultiShotResultCount() const
{
	return (int)m_vecWsiMultiShotResult.size();
}

// review schedule result
const VectorReviewScheduleResult* CGlassResult::GetVectorReviewScheduleResult() const	
{ 
	return &m_vecReviewScheduleResult; 
}

VectorReviewScheduleResult*	CGlassResult::GetVectorReviewScheduleResult() 	
{ 
	return &m_vecReviewScheduleResult;
}

int	CGlassResult::GetReviewScheduleResultCount() const	
{ 
	return (int)m_vecReviewScheduleResult.size();
}

// user schedule result
const VectorReviewScheduleResult* CGlassResult::GetVectorUserScheduleResult() const	
{ 
	return &m_vecUserScheduleResult; 
}

VectorReviewScheduleResult*	CGlassResult::GetVectorUserScheduleResult() 	
{ 
	return &m_vecUserScheduleResult;
}

int	CGlassResult::GetUserScheduleResultCount() const	
{ 
	return (int)m_vecUserScheduleResult.size();
}

// wsi schedule result
const VectorReviewScheduleResult* CGlassResult::GetVectorWsiScheduleResult() const	
{ 
	return &m_vecWsiScheduleResult; 
}

VectorReviewScheduleResult*	CGlassResult::GetVectorWsiScheduleResult() 
{ 
	return &m_vecWsiScheduleResult;
}

int	CGlassResult::GetWsiScheduleResultCount() const		
{
	return (int)m_vecWsiScheduleResult.size(); 
}

// Measure schedule result
const VectorReviewScheduleResult* CGlassResult::GetVectorMeasureScheduleResult() const		
{
	return &m_vecMeasureScheduleResult;
}

VectorReviewScheduleResult*	CGlassResult::GetVectorMeasureScheduleResult()				
{ 
	return &m_vecMeasureScheduleResult; 
}

int	CGlassResult::GetMeasureScheduleResultCount() const			
{ 
	return (int)m_vecMeasureScheduleResult.size(); 
}

// reflow schedule result
const VectorReviewScheduleResult* CGlassResult::GetVectorReflowScheduleResult() const
{
	return &m_vecReflowScheduleResult;
}

VectorReviewScheduleResult* CGlassResult::GetVectorReflowScheduleResult()
{
	return &m_vecReflowScheduleResult;
}

int CGlassResult::GetReflowScheduleResultCount() const
{
	return (int)m_vecReflowScheduleResult.size();
}
// wsi reflow schedule result
const VectorReviewScheduleResult* CGlassResult::GetVectorWsiReflowScheduleResult() const
{
	return &m_vecWsiReflowScheduleResult;
}

VectorReviewScheduleResult* CGlassResult::GetVectorWsiReflowScheduleResult()
{
	return &m_vecWsiReflowScheduleResult;
}

int CGlassResult::GetWsiReflowScheduleResultCount() const
{
	return (int)m_vecWsiReflowScheduleResult.size();
}

BOOL CGlassResult::SetWsiReflowResultData( int nModuleIdx, int nResultIdx, const SReviewResult& wsiResult, int nGlassPosX, int nGlassPosY, int nMotorPosX, int nMotorPosY, double dDurationTime )
{
	EnterCriticalSection(&m_csProcess);

	BOOL bReturn = FALSE;
	SReviewResult* pSWsiResult = GetSWsiReflowResult(nModuleIdx, nResultIdx);
	if (pSWsiResult)
	{
		// nWsi_ResultCode ´©¶ô ¼öÁ¤ [6/20/2017 bhs]
		pSWsiResult->nWsi_ResultCode		= wsiResult.nWsi_ResultCode;
		pSWsiResult->dWsi_DamDistance		= wsiResult.dWsi_DamDistance;

		for(int nCnt=0; nCnt < WsiReflowInfo_Result_Info_Count; nCnt++)
		{
			pSWsiResult->nWsi_pReflowResultData[nCnt]	= wsiResult.nWsi_pReflowResultData[nCnt];
		}

		// bug fix [6/20/2017 bhs]
		//if (wsiResult.nResultCode==1)
		if (pSWsiResult->nWsi_ResultCode == 1)
		{
			pSWsiResult->nResultCode = WsiResultSuccess;
		}
		else
		{
			pSWsiResult->nResultCode = WsiResult_Fail;
		}

		bReturn = TRUE;
	}

	LeaveCriticalSection(&m_csProcess);

	return bReturn;
}

BOOL CGlassResult::SetUserWsiResultData( int nModuleIdx, int nResultIdx, const SReviewResult& wsiResult, int nGlassPosX, int nGlassPosY, int nMotorPosX, int nMotorPosY, double dDurationTime )
{
	EnterCriticalSection(&m_csProcess);

	BOOL bReturn = FALSE;
	SReviewResult* pSWsiResult = GetSWsiUserResult(nModuleIdx, nResultIdx);
	if (pSWsiResult)
	{
		// nWsi_ResultCode ´©¶ô ¼öÁ¤ [6/20/2017 bhs]
		pSWsiResult->nWsi_ResultCode		= wsiResult.nWsi_ResultCode;
		pSWsiResult->nWsi_Type				= wsiResult.nWsi_Type;
		pSWsiResult->nWsi_SlopeWarn			= wsiResult.nWsi_SlopeWarn;
		pSWsiResult->bBigSizeDefect = wsiResult.bBigSizeDefect;
		memcpy(pSWsiResult->pWsi_ResultData, wsiResult.pWsi_ResultData, sizeof(wsiResult.pWsi_ResultData));

		// bug fix [6/20/2017 bhs]
		//if (wsiResult.nResultCode==1)
		if (pSWsiResult->nWsi_ResultCode == 1)
		{
			pSWsiResult->nResultCode = WsiResultSuccess;
		}
		else
		{
			pSWsiResult->nResultCode = WsiResult_Fail;
		}

		bReturn = TRUE;
	}

	LeaveCriticalSection(&m_csProcess);

	return bReturn;
}

BOOL CGlassResult::SetWSIMultiShotResultData(int nModuleIdx, int nResultIdx, const SReviewResult& wsiResult, int nGlassPosX, int nGlassPosY, int nMotorPosX, int nMotorPosY, double dDurationTime)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bReturn = FALSE;
	SReviewResult* pSWsiMultiShotResult = GetSWsiMultiShotResult(nModuleIdx, nResultIdx);
	if (pSWsiMultiShotResult)
	{
		// nWsi_ResultCode ´©¶ô ¼öÁ¤ [6/20/2017 bhs]
		pSWsiMultiShotResult->nWsi_ResultCode = wsiResult.nWsi_ResultCode;
		pSWsiMultiShotResult->nWsi_Type = wsiResult.nWsi_Type;
		pSWsiMultiShotResult->nWsi_SlopeWarn = wsiResult.nWsi_SlopeWarn;
		pSWsiMultiShotResult->bBigSizeDefect = wsiResult.bBigSizeDefect;


		memcpy(pSWsiMultiShotResult->pWsi_ResultData, wsiResult.pWsi_ResultData, sizeof(wsiResult.pWsi_ResultData));

		// bug fix [6/20/2017 bhs]
		//if (wsiResult.nResultCode==1)
		if (pSWsiMultiShotResult->nWsi_ResultCode == 1)
		{
			pSWsiMultiShotResult->nResultCode = WsiResultSuccess;
		}
		else
		{
			pSWsiMultiShotResult->nResultCode = WsiResult_Fail;
		}

		bReturn = TRUE;
	}

	LeaveCriticalSection(&m_csProcess);

	return bReturn;
}

SReviewResult* CGlassResult::GetSWsiUserResult( int nModuleIdx, int nResultIdx )
{
	CReviewResult* pResult = GetWsiUserResult(nModuleIdx);
	if(pResult == NULL) return NULL;
	return pResult->GetSReviewResult(nResultIdx);
}

const SReviewResult* CGlassResult::GetSWsiUserResult( int nModuleIdx, int nResultIdx ) const
{
	const CReviewResult* pResult = GetWsiUserResult(nModuleIdx);
	if(pResult == NULL) return NULL;
	return pResult->GetSReviewResult(nResultIdx);
}

BOOL CGlassResult::CheckWsiUserComplete( int nModuleIdx/*=-1*/ )
{
	EnterCriticalSection(&m_csProcess);

	BOOL bRet = TRUE;
	if (nModuleIdx==-1)
	{
		for (constVectorReviewResultIt it=m_vecWsiUserResult.begin(); it!=m_vecWsiUserResult.end(); it++)
		{
			// Á¶°Ç¹® ¼öÁ¤ [6/20/2017 bhss]
			//bRet = bRet && it->CheckComplete();
			bRet &= it->CheckComplete();

			if (bRet==FALSE) break;
		}
	}
	else
	{
		bRet = FALSE;
		CReviewResult *pWsiResult = GetWsiUserResult(nModuleIdx);
		if (pWsiResult)
		{
			bRet = pWsiResult->CheckComplete();
		}
	}

	LeaveCriticalSection(&m_csProcess);

	return bRet;
}
BOOL CGlassResult::CheckWsiMultiShotComplete(int nModuleIdx/*=-1*/)
{
	EnterCriticalSection(&m_csProcess);

	BOOL bRet = TRUE;
	if (nModuleIdx == -1)
	{
		for (constVectorReviewResultIt it = m_vecWsiMultiShotResult.begin(); it != m_vecWsiMultiShotResult.end(); it++)
		{
			// Á¶°Ç¹® ¼öÁ¤ [6/20/2017 bhss]
			//bRet = bRet && it->CheckComplete();
			bRet &= it->CheckComplete();

			if (bRet == FALSE) break;
		}
	}
	else
	{
		bRet = FALSE;
		CReviewResult *pWsiResult = GetWsiMultiShotResult(nModuleIdx);
		if (pWsiResult)
		{
			bRet = pWsiResult->CheckComplete();
		}
	}

	LeaveCriticalSection(&m_csProcess);

	return bRet;
}