#include "StdAfx.h"
#include "PostProcess.h"
#include "Config.h"
#include "FreeImage.h"
#include "Glass_Data.h"
#include "GlassRecipe.h"
#include "Transfer_Data.h"
#include "InspectCamera.h"
#include "EdgeInspector_AppView.h"

#include <ctime>

#define JPEG_RATE			JPEG_QUALITYNORMAL|JPEG_OPTIMIZE

CPostProcess::CPostProcess(void)
{
	m_pView = NULL;
	InitPostProcessing();
}

CPostProcess::~CPostProcess(void)
{	
}

void CPostProcess::SetInspectCamera(int iCam,CInspectCamera *pIns)
{
	m_pInspectCamera[iCam] = pIns;
}

void CPostProcess::SetPrameter(CGlass_Data *pGlsData,CHardwareSettings *pHW,CGlassRecipe *pRecipe,CTransfer_Data *pTransData)
{
	m_pGlassData	= pGlsData;
	m_pHardware		= pHW;
	m_pRecipe		= pRecipe;
	m_pTransData	= pTransData;
}

void CPostProcess::WriteSetupData()
{
	if(m_pView != NULL)
		((CEdgeInspector_AppView*) m_pView)->SetupImageSave();

	CString strSetupDataPath;
	strSetupDataPath.Format(_T("D:\\Inspection\\Data\\SetupData.csv"));
	
	CFile file_module;
	CFileException file_exception;

	file_module.Open(strSetupDataPath, CFile::modeCreate|CFile::modeWrite|CFile::modeNoTruncate|CFile::shareDenyWrite|CFile::shareDenyRead, &file_exception);

	if(file_exception.m_cause == CFileException::none)
	{
		if(file_module.SeekToEnd() == 0L)
		{
			CString title;
			title.Format(_T("Time, ID, Side, Find Start Line, Find End Line, Pre End Line, Top Mark X, Top Mark Y, Bot Mark X, Bot Mark Y\r\n"));
			file_module.Write(title, title.GetLength()*sizeof(TCHAR));
		}

		CTime currentTime = CTime::GetCurrentTime();

		g_pLog->DisplayMessage(_T("=========== Set-up Data (%d/%d/%d - %d:%d:%d)=============="),currentTime.GetYear(), currentTime.GetMonth(), currentTime.GetDay(), currentTime.GetHour(), currentTime.GetMinute(), currentTime.GetSecond());

		for(int i=0; i<MAX_SIDE_COUNT; i++)
		{
			CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) i);

			CString strData;
			strData.Format(_T("%s, %s, %s, %d, %d, %d, %d, %d, %d, %d\r\n"), m_pGlassData->GetLoadingTimeString(), _T("Setup"), g_SideName[i], pSideData->m_nGlassStartLine, pSideData->m_nGlassEndLine, pSideData->m_nPreGlassEndLine, pSideData->m_ptTopMark_FindResult.x, pSideData->m_ptTopMark_FindResult.y, pSideData->m_ptBotMark_FindResult.x, pSideData->m_ptBotMark_FindResult.y);
			file_module.Write(strData, strData.GetLength()*sizeof(TCHAR));

			g_pLog->DisplayMessage(_T("%d. %s ===="), i+1, g_SideName[i]);
			g_pLog->DisplayMessage(_T("Side[%s] Find Start Line - %d pixel"), g_SideName[i], pSideData->m_nGlassStartLine);
			g_pLog->DisplayMessage(_T("Side[%s] Find End Line - %d pixel"), g_SideName[i], pSideData->m_nGlassEndLine);
			g_pLog->DisplayMessage(_T("Side[%s] Find Pre End Line - %d pixel"), g_SideName[i], pSideData->m_nPreGlassEndLine);
			g_pLog->DisplayMessage(_T("Side[%s] Top Align Mark - (%d, %d) pixel"), g_SideName[i], pSideData->m_ptTopMark_FindResult.x, pSideData->m_ptTopMark_FindResult.y);
			g_pLog->DisplayMessage(_T("Side[%s] Bot Align Mark - (%d, %d) pixel"), g_SideName[i], pSideData->m_ptBotMark_FindResult.x, pSideData->m_ptBotMark_FindResult.y);
			g_pLog->DisplayMessage(_T("==========="));
		}

		g_pLog->DisplayMessage(_T("=========== End Set-up Data (%d/%d/%d - %d:%d:%d)=============="),currentTime.GetYear(), currentTime.GetMonth(), currentTime.GetDay(), currentTime.GetHour(), currentTime.GetMinute(), currentTime.GetSecond());

		file_module.Close();
	}
}

BOOL CPostProcess::InitPostProcessing()
{
	m_pGlassData = NULL;
	m_pHardware = NULL;
	m_pRecipe = NULL;

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

	return TRUE;
}

BOOL CPostProcess::ProcessingScanEnd()
{
	
	return TRUE;
}

BOOL CPostProcess::RunPostProcessing()
{
	g_pLog->DisplayMessage(_T("Start RunPostProcessing - Defect Process"));

	if(m_pGlassData == NULL)
	{
		g_pLog->DisplayMessage(_T("Glass Data is NULL"));
		return FALSE;
	}
	
	CreateDataDirectory();

	MergeDefect();

	// WriteSetupData();

	g_pLog->DisplayMessage(_T("Before - Total Defect Count : Tot %d, NG %d, OK %d"),m_pGlassData->GetTotalDefectCount(),m_pGlassData->GetDefectCount_NG(), m_pGlassData->GetDefectCount_OK());
	
	PostDefectJudgeProcess();

	g_pLog->DisplayMessage(_T("After - Total Defect Count : Tot %d, NG %d, OK %d"),m_pGlassData->GetTotalDefectCount(),m_pGlassData->GetDefectCount_NG(), m_pGlassData->GetDefectCount_OK());
	
#if MINI_LED

	if(m_pGlassData->GetSimulation() == FALSE)
	{
		WriteDefectFile();
		WriteMapFile();
		WriteDataFile();
	}
#endif
	return TRUE;
}

BOOL CPostProcess::RunPostProcessing_SaveDefectInfo()
{
	g_pLog->DisplayMessage(_T("Start RunPostProcessing - Save Defect Info Process"));

	if(m_pGlassData == NULL)
	{
		g_pLog->DisplayMessage(_T("Glass Data is NULL"));
		return FALSE;
	}

	// Save Defect Data..
	SaveDefectData();

	// Save Defect Image..
	SaveDefectImageNG();

	return TRUE;
}

BOOL CPostProcess::RunPostProcessing_SaveFiltImage()
{
	g_pLog->DisplayMessage(_T("Start RunPostProcessing - Save Defect Info Process"));

	if (m_pGlassData == NULL)
	{
		g_pLog->DisplayMessage(_T("Glass Data is NULL"));
		return FALSE;
	}

	SaveDefectImageOK();

	return TRUE;
}

void CPostProcess::SaveDefectData()
{
	CString glass_id;
	glass_id.Format(_T("%s"), g_pBase->m_strHPanelID);

	if (glass_id.IsEmpty() == TRUE)
		glass_id.Format(_T("MANUAL_ID"));

	// 获取当前产品加载时间
	CTime tGlassLoading = m_pGlassData->GetLoadingTime();

	CString measure_data;
	CString chip_data;
	CString defect_data;
	CString	strTime = g_pBase->m_strLoadingTime;

	double dTFTYOff = 0;
	//double dSumTFTYOff = 0;
	//int nCountTFTYOff = 0;
	//for (int nFrameIdx = 0; nFrameIdx < MAX_IMAGE_FRAME; nFrameIdx++)
	//{
	//	if (m_pGlassData->GetSideData(DIMENSION_B)->m_nSide_Electrode_Result_um[nFrameIdx] == -1) continue;
	//	dSumTFTYOff += m_pGlassData->GetSideData(DIMENSION_B)->m_nSide_Electrode_Result_um[nFrameIdx];
	//	nCountTFTYOff++;
	//}
	//if (nCountTFTYOff > 0)
	//	dTFTYOff = dSumTFTYOff / nCountTFTYOff;

	double dTFTXOff = 0;
	//double dSumTFTXOff = 0;
	//int nCountTFTXOff = 0;
	//for (int nFrameIdx = 0; nFrameIdx < MAX_IMAGE_FRAME; nFrameIdx++)
	//{
	//	if (m_pGlassData->GetSideData(DIMENSION_A)->m_nSide_Electrode_Result_um[nFrameIdx] == -1) continue;
	//	dSumTFTXOff += m_pGlassData->GetSideData(DIMENSION_A)->m_nSide_Electrode_Result_um[nFrameIdx];
	//	nCountTFTXOff++;
	//}
	//if (nCountTFTXOff > 0)
	//	dTFTXOff = dSumTFTXOff / nCountTFTXOff;

	double nPanelSizeCF_X = ((m_pGlassData->GetSideData(DIMENSION_B)->m_nGlassEndLine - m_pGlassData->GetSideData(DIMENSION_B)->m_nGlassStartLine) * m_pGlassData->GetSideData(DIMENSION_B)->m_dPixelSizeY / 1000.0);
	double nPanelSizeCF_Y = ((m_pGlassData->GetSideData(DIMENSION_A)->m_nGlassEndLine - m_pGlassData->GetSideData(DIMENSION_A)->m_nGlassStartLine) * m_pGlassData->GetSideData(DIMENSION_A)->m_dPixelSizeY / 1000.0);
	double nPanelSizeTFT_X = (((m_pGlassData->GetSideData(DIMENSION_B)->m_nGlassEndLine - m_pGlassData->GetSideData(DIMENSION_B)->m_nGlassStartLine) * m_pGlassData->GetSideData(DIMENSION_B)->m_dPixelSizeY - dTFTXOff) / 1000.0);
	double nPanelSizeTFT_Y = (((m_pGlassData->GetSideData(DIMENSION_A)->m_nGlassEndLine - m_pGlassData->GetSideData(DIMENSION_A)->m_nGlassStartLine) * m_pGlassData->GetSideData(DIMENSION_A)->m_dPixelSizeY - dTFTYOff) / 1000.0);

	measure_data.AppendFormat(_T("%s,%s,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%f,%f,%f,%f,%d,%d,%d,%d,%d,%d,%d,%d"),
		strTime,
		glass_id,
		m_pTransData->m_nUnitNo,
		m_pTransData->m_nEqpNo,
		m_pTransData->m_nisGrind,
		m_pTransData->m_nRoughPadLayer,
		MeasrueCutLineResult(DIMENSION_A),
		MeasrueCutLineResult(DIMENSION_B),
		MeasrueCutLineResult(DIMENSION_C),
		MeasrueCutLineResult(DIMENSION_D),
		MeasrueCutLineResult(DIMENSION_A_DN),
		MeasrueCutLineResult(DIMENSION_B_DN),
		MeasrueCutLineResult(DIMENSION_C_DN),
		MeasrueCutLineResult(DIMENSION_D_DN),
		nPanelSizeCF_X,
		nPanelSizeCF_Y,
		nPanelSizeTFT_X,
		nPanelSizeTFT_Y,
		m_pGlassData->GetSideData(DIMENSION_A)->m_nTopCornerWidth,
		m_pGlassData->GetSideData(DIMENSION_A)->m_nTopCornerHeight,
		m_pGlassData->GetSideData(DIMENSION_A)->m_nBottomCornerWidth,
		m_pGlassData->GetSideData(DIMENSION_A)->m_nBottomCornerHeight,
		m_pGlassData->GetSideData(DIMENSION_C)->m_nTopCornerWidth,
		m_pGlassData->GetSideData(DIMENSION_C)->m_nTopCornerHeight,
		m_pGlassData->GetSideData(DIMENSION_C)->m_nBottomCornerWidth,
		m_pGlassData->GetSideData(DIMENSION_C)->m_nBottomCornerHeight
	);
	measure_data.Append(_T("\r\n"));

	CString measure_file_path;
	if (m_pHardware->m_bSaveResultByHour) {
		// 按小时保存结果
		measure_file_path.Format(_T("%s\\%s_%02d_MeasureData.csv"), m_strResultFolder, g_pBase->m_strLoadingDay, tGlassLoading.GetHour());
	}
	else {
		// 不按小时保存结果
		measure_file_path.Format(_T("%s\\%s_MeasureData.csv"), m_strResultFolder, g_pBase->m_strLoadingDay);
	}

	CheckDirectory(measure_file_path);

	CFile measure_module;
	CFileException measure_exception;

	measure_module.Open(measure_file_path, CFile::modeCreate | CFile::modeWrite | CFile::modeNoTruncate | CFile::shareDenyWrite | CFile::shareDenyRead, &measure_exception);

	if (measure_exception.m_cause == CFileException::none)
	{
		if (measure_module.SeekToEnd() == 0L)
		{
			CString defect_title;
			defect_title.Format(_T("Time,Glass ID,Unit_No,Table_No,Slot_No,Panel_count,AT_SizeAVG,BT_SizeAVG,CT_SizeAVG,DT_SizeAVG,AB_SizeAVG,BB_SizeAVG,CB_SizeAVG,DB_SizeAVG,CF_SizeX,CF_SizeY,TFT_SizeX,TFT_SizeY,AT_CorX,AT_CorY,AB_CorX,AB_CorY,CT_CorX,CT_CorY,CB_CorX,CB_CorY\r\n"));
			measure_module.Write(defect_title, defect_title.GetLength() * sizeof(TCHAR));
		}
		measure_module.Write(measure_data, measure_data.GetLength() * sizeof(TCHAR));
		measure_module.Close();
	}

	{
		MapDefectIt it;
		MapDefect* pMapDefect = m_pGlassData->GetMapDefect_OK();

		for (it = pMapDefect->begin(); it != pMapDefect->end(); it++)
		{
			CDefect* pDefect = static_cast<CDefect*>(it->second);

			if (pDefect == NULL)
				continue;

			if (pDefect->m_bJudge_NG == TRUE)
				continue;

			CString strDefectType = g_strDefectType[pDefect->m_DefectInfo.m_DefectLoc];
			if ((strDefectType.Compare(_T("Chip")) == 0 || strDefectType.Compare(_T("In_Chip")) == 0))
			{
				// 获取当前时间
				std::time_t now = std::time(nullptr);
				// 使用localtime_s代替localtime
				std::tm nowTm;
				localtime_s(&nowTm, &now);

				CString strDate;
				strDate.Format(_T("%04d%02d%02d%02d%02d%02d"),
					nowTm.tm_year + 1900, nowTm.tm_mon + 1, nowTm.tm_mday, nowTm.tm_hour, nowTm.tm_min, nowTm.tm_sec);

				CString strCLCS;
				m_pGlassData->DecodeDefectPose(&(pDefect->m_DefectInfo), strCLCS);

#if HALCON_VISION_KEY
				Point2I pos2I = BlVision_GetSoftVisionApp()->getPose(pDefect->m_DefectInfo.m_nSideIdx, pDefect->m_DefectInfo.m_ptDefectPos_pxl.x, pDefect->m_DefectInfo.m_ptDefectPos_pxl.y);
#else
				CPoint pos2I = m_pGlassData->TransformToGlobal((DimensionDir)pDefect->m_DefectInfo.m_nSideIdx, pDefect->m_DefectInfo.m_ptDefectPos_pxl);
#endif // HALCON_VISION_KEY

				int nMinSize_X = m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[(int)pDefect->m_DefectInfo.m_DefectLoc].m_nMinSize_Filter_X_um;
				int nMinSize_Y = m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[(int)pDefect->m_DefectInfo.m_DefectLoc].m_nMinSize_Filter_Y_um;;

				if (static_cast<int>(round(pDefect->m_dSizeX_um)) > nMinSize_X && static_cast<int>(round(pDefect->m_dSizeY_um)) > nMinSize_Y)
				{
					chip_data.AppendFormat(_T("%s,%s,%s,%s,%s,%s,%s,%f,%f,%d,%d"),
						strDate,
						glass_id,
						g_pBase->m_strRecipeName,
						g_pBase->m_strSBKLine,
						PANEL_SIDE[pDefect->m_DefectInfo.m_nSideIdx],
						strCLCS,
						pDefect->m_DefectInfo.m_nSideIdx >= 0 && pDefect->m_DefectInfo.m_nSideIdx < 4 ? _T("CF") : _T("TFT"),
						pDefect->m_dSizeY_um,
						pDefect->m_dSizeX_um,
						std::abs(pos2I.x),
						std::abs(pos2I.y));
					chip_data.Append(_T("\r\n"));
				}
			}
		}
	}

	{
		MapDefectIt it;
		MapDefect* pMapDefect = m_pGlassData->GetMapDefect_NG();

		for (it = pMapDefect->begin(); it != pMapDefect->end(); it++)
		{
			CDefect* pDefect = static_cast<CDefect*>(it->second);

			if (pDefect == NULL)
				continue;

			if (pDefect->m_bJudge_NG == FALSE)
				continue;

			CString strDefectType = g_strDefectType[pDefect->m_DefectInfo.m_DefectLoc];

			CString strEqip, strUnit;

			CTransfer_Data* pTrans = m_pTransData;
			if (pTrans != NULL)
			{
				strEqip.Format(_T("%d"), pTrans->m_nEqpNo);
				strUnit.Format(_T("%d"), pTrans->m_nUnitNo);
			}
			else
			{
				strEqip.Format(_T("%d"), 0);
				strUnit.Format(_T("%d"), 0);
			}

			defect_data.AppendFormat(_T("%s,%s,%s,%s,%s,%s,%f,%f,%s"),
				strTime,
				glass_id,
				strEqip,
				strUnit,
				PANEL_SIDE[pDefect->m_DefectInfo.m_nSideIdx],
				strDefectType,
				pDefect->m_dSizeX_um,
				pDefect->m_dSizeY_um,
				pDefect->m_strSaveImagePath);
			defect_data.Append(_T("\r\n"));

			if ((strDefectType.Compare(_T("Chip")) == 0 || strDefectType.Compare(_T("In_Chip")) == 0))
			{
				// 获取当前时间
				std::time_t now = std::time(nullptr);
				// 使用localtime_s代替localtime
				std::tm nowTm;
				localtime_s(&nowTm, &now);

				CString strDate;
				strDate.Format(_T("%04d%02d%02d%02d%02d%02d"),
					nowTm.tm_year + 1900, nowTm.tm_mon + 1, nowTm.tm_mday, nowTm.tm_hour, nowTm.tm_min, nowTm.tm_sec);

				CString strCLCS;
				m_pGlassData->DecodeDefectPose(&(pDefect->m_DefectInfo), strCLCS);
				CPoint pos2I = m_pGlassData->TransformToGlobal((DimensionDir)pDefect->m_DefectInfo.m_nSideIdx, pDefect->m_DefectInfo.m_ptDefectPos_pxl);

				chip_data.AppendFormat(_T("%s,%s,%s,%s,%s,%s,%s,%f,%f,%d,%d"),
					strDate,
					glass_id,
					g_pBase->m_strRecipeName,
					g_pBase->m_strSBKLine,
					PANEL_SIDE[pDefect->m_DefectInfo.m_nSideIdx],
					strCLCS,
					pDefect->m_DefectInfo.m_nSideIdx >= 0 && pDefect->m_DefectInfo.m_nSideIdx < 4 ? _T("CF") : _T("TFT"),
					pDefect->m_dSizeY_um,
					pDefect->m_dSizeX_um,
					std::abs(pos2I.y),
					std::abs(pos2I.x));
				chip_data.Append(_T("\r\n"));
			}
		}
	}

	CString Chip_file_path;
	if (m_pHardware->m_bSaveResultByHour) {
		// 按小时保存结果
		Chip_file_path.Format(_T("%s\\%s_%02d_ChipData.csv"), m_strResultFolder, g_pBase->m_strLoadingDay, tGlassLoading.GetHour());
	}
	else {
		// 不按小时保存结果
		Chip_file_path.Format(_T("%s\\%s_ChipData.csv"), m_strResultFolder, g_pBase->m_strLoadingDay);
	}
	
	CheckDirectory(Chip_file_path);

	CFile chip_module;
	CFileException chip_exception;

	chip_module.Open(Chip_file_path, CFile::modeCreate | CFile::modeWrite | CFile::modeNoTruncate | CFile::shareDenyWrite | CFile::shareDenyRead, &chip_exception);

	if (chip_exception.m_cause == CFileException::none)
	{
		if (chip_module.SeekToEnd() == 0L)
		{
			CString defect_title;
			defect_title.Format(_T("Date,GlassID,Model,SBK Line,Side,C-L/C-S,TFT/CF,Length,Depth,PosX,PosY\r\n"));
			chip_module.Write(defect_title, defect_title.GetLength() * sizeof(TCHAR));
		}
		chip_module.Write(chip_data, chip_data.GetLength() * sizeof(TCHAR));
		chip_module.Close();
	}

	CString Defect_file_path;
	if (m_pHardware->m_bSaveResultByHour) {
		// 按小时保存结果
		Defect_file_path.Format(_T("%s\\%s_%02d_DefectData.csv"), m_strResultFolder, g_pBase->m_strLoadingDay, tGlassLoading.GetHour());
	}
	else {
		// 不按小时保存结果
		Defect_file_path.Format(_T("%s\\%s_DefectData.csv"), m_strResultFolder, g_pBase->m_strLoadingDay);
	}

	CheckDirectory(Defect_file_path);

	CFile defect_module;
	CFileException defect_exception;

	defect_module.Open(Defect_file_path, CFile::modeCreate | CFile::modeWrite | CFile::modeNoTruncate | CFile::shareDenyWrite | CFile::shareDenyRead, &defect_exception);

	if (defect_exception.m_cause == CFileException::none)
	{
		if (defect_module.SeekToEnd() == 0L)
		{
			CString defect_title;
			defect_title.Format(_T("TIME,ID,EQP NO,UNIT NO,SIDE,LOCATION,SIZE_X,SIZE_Y,IMAGE_PATH\r\n"));
			defect_module.Write(defect_title, defect_title.GetLength()*sizeof(TCHAR));
		}
		defect_module.Write(defect_data, defect_data.GetLength()*sizeof(TCHAR));
		defect_module.Close();
	}
}

void CPostProcess::JudgementData()
{
	if(m_pGlassData == NULL)
		return;

	/*
	PROFILECHAMFER_RESULT_DATA *pResult = m_pGlassData->GetProfileInspectData();
	PROFILE_RESULT	*pProfileRes;
	int			index;
	
	for(index=0;index<MAX_PROFILE_SETTING_COUNT;index++)
	{
		pProfileRes = &pResult->ProfileData[index];

		pProfileRes->bProfileJudge = TRUE;
		if(pProfileRes->bUseJudge == TRUE)
		{
			if(pProfileRes->nProfileDiff < -1*pProfileRes->nJudgeMinus || pProfileRes->nProfileDiff > pProfileRes->nJudgePlus)
			{
				pProfileRes->bProfileJudge = FALSE;
			}
		}

		for(int i=0;i<2;i++)
		{
			CHAMFER_RESULT *pChamferRes = &pResult->ResultChamfer[index][i];
			pChamferRes->bChamferJudge = TRUE;
			if(pChamferRes->bUseJudge == TRUE)
			{
				if(pChamferRes->nChamferThick < pChamferRes->nJudgeReference - pChamferRes->nJudgeMinusChamfer || pChamferRes->nChamferThick > pChamferRes->nJudgeReference+pChamferRes->nJudgePlusChamfer)
				{
					pChamferRes->bChamferJudge = FALSE;
					//InsertManualDefect(pInspect,m_pHardware->GetCameraSettings(pProfileRes->iCam,pProfileRes->iScan),pProfileRes->iScan,pProfileRes->ptGlassStart.x,pProfileRes->ptGlassStart.y,DefectLoc_Chamfer);
				}
			}
		}
	}
	*/
}

BOOL CPostProcess::SaveDefectImage(LPBYTE pImage,CSize szImage,CRect rectDefect,CString strFile,DimensionDir emDir)
{
	if (pImage == NULL || szImage.cx <= 0 || szImage.cy <= 0) {
		g_pLog->DisplayMessage(_T("Invalid image data or size"));
		return FALSE;
	}

	Lock();
	FIBITMAP* bitmap = FreeImage_Allocate(szImage.cx, szImage.cy, 8);
	if (bitmap == NULL) {
		g_pLog->DisplayMessage(_T("FreeImage_Allocate failed"));
		Unlock();
		return FALSE;
	}

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

	CopyMemory(pBitBuffer, pImage, szImage.cx * szImage.cy);

	FIBITMAP *pBit24 = FreeImage_ConvertTo24Bits(bitmap);
	if (pBit24 == NULL) {
		Unlock();
		return FALSE;
	}

	char cFilePath[255];

#ifdef _UNICODE
	int	nSize = WideCharToMultiByte(CP_ACP, 0, strFile.GetBuffer(), -1, NULL, 0, NULL,NULL); 				
	WideCharToMultiByte(CP_ACP, 0, strFile.GetBuffer(), -1, cFilePath, nSize, NULL, NULL); 
#else				
	sprintf_s(cFilePath,sizeof(char)*255,_T("%s"),(LPSTR)(LPCTSTR)strFile);	
#endif	

	FreeImage_FlipVertical(pBit24);
	FreeImage_Save(FIF_JPEG, pBit24, cFilePath,JPEG_RATE);	
	FreeImage_Unload(bitmap);
	FreeImage_Unload(pBit24);

	Unlock();

	return TRUE;
}

BOOL CPostProcess::SaveDefectImageModern(LPBYTE pImage,CSize szImage,CRect rectDefect,CString strFile)
{
	if (!pImage || szImage.cx <= 0 || szImage.cy <= 0) {
		return FALSE;
	}

#if 0
	IplImage* pImageTmp = cvCreateImage(cvSize(szImage.cx, szImage.cy), 8, 1);
	cvZero(pImageTmp);

	// add point to the image
	for (int i = 0; i < szImage.cy; i++) {
		for (int j = 0; j < szImage.cx; j++) {
			pImageTmp->imageData[i * pImageTmp->widthStep + j] = pImage[i * szImage.cx + j];
		}
	}

	IplImage* pColorImg = cvCreateImage(cvSize(szImage.cx, szImage.cy), 8, 3);
	cvZero(pColorImg);

	cvCvtColor(pImageTmp, pColorImg, CV_GRAY2BGR);
	cvRectangle(pColorImg, CvPoint(rectDefect.left, rectDefect.top), CvPoint(rectDefect.left + rectDefect.Width(), rectDefect.top + rectDefect.Height()), cvScalar(0, 0, 255), 1);

	USES_CONVERSION;
	char str_filename[1024];
	sprintf_s(str_filename, "%s", W2A(strFile));
	cvSaveImage(str_filename, pColorImg);

	cvReleaseImage(&pColorImg);
	cvReleaseImage(&pImageTmp);
#else
	Lock();
	cv::Mat grayImg(szImage.cy, szImage.cx, CV_8UC1, pImage);
	cv::Mat colorImg;
	cv::cvtColor(grayImg, colorImg, cv::COLOR_GRAY2BGR);

	cv::rectangle(
		colorImg,
		cv::Rect(rectDefect.left, rectDefect.top, rectDefect.Width(), rectDefect.Height()),
		cv::Scalar(0, 0, 255),
		1
	);

	USES_CONVERSION;
	std::string strFilename = W2A(strFile);

	if (!cv::imwrite(strFilename, colorImg)) {
		Unlock();
		g_pLog->DisplayMessage(_T("Failed to save image to %s"), strFile);
		return FALSE;
	}
	Unlock();
#endif // 0

	return TRUE;
}

BOOL CPostProcess::SaveDefectImage_with_Title(CDefect* pDefect, CSize szImage,CRect rectDefect,CString strFile, CvScalar color)
{
	if (pDefect == NULL || pDefect->m_Image == NULL) {
		g_pLog->DisplayMessage(_T("Invalid defect data or image"));
		return FALSE;
	}

	if (szImage.cx <= 0 || szImage.cy <= 0) {
		g_pLog->DisplayMessage(_T("Invalid image size: %d x %d"), szImage.cx, szImage.cy);
		return FALSE;
	}

	BOOL bSuccess = TRUE;

	Lock();
	// 标题文本
	CString strTitle;
	int nSideIdx = (0 <= pDefect->m_DefectInfo.m_nSideIdx && pDefect->m_DefectInfo.m_nSideIdx < MAX_SIDE_COUNT) ? pDefect->m_DefectInfo.m_nSideIdx : MAX_SIDE_COUNT;
	int nCategoryIdx = (0 <= pDefect->m_DefectInfo.m_DefectLoc && pDefect->m_DefectInfo.m_DefectLoc < DefectLoc_None) ? pDefect->m_DefectInfo.m_DefectLoc : DefectLoc_Unknown;
	
	DefectLocation eCategory = pDefect->m_DefectInfo.m_DefectLoc;
	if (eCategory == DefectLoc_Notch_Dimension || eCategory == DefectLoc_Notch_Chamfer) {
		strTitle.Format(_T("SIDE[%s] CAT[%s] SIZE[%d,%d] distance[%d,%d] "), g_SideName[nSideIdx], g_strDefectType[nCategoryIdx], (int)pDefect->m_dSizeX_um, (int)pDefect->m_dSizeY_um, (int)pDefect->m_dChamfer_um, (int)pDefect->m_dChamferOff_um);
	}
	else {
		strTitle.Format(_T("SIDE[%s] CAT[%s] SIZE[%d,%d]"), g_SideName[nSideIdx], g_strDefectType[nCategoryIdx], (int)pDefect->m_dSizeX_um, (int)pDefect->m_dSizeY_um);
	}
	Unlock();

	try {
		Lock();
		cv::Mat imgTmp(szImage.cy, szImage.cx, CV_8UC1, pDefect->m_Image);
		cv::Mat colorImg(szImage.cy, szImage.cx, CV_8UC3);
		cv::cvtColor(imgTmp, colorImg, cv::COLOR_GRAY2BGR);

		cv::rectangle(colorImg, cv::Point(rectDefect.left, rectDefect.top), cv::Point(rectDefect.right, rectDefect.bottom), color, 1);
		cv::rectangle(colorImg, cv::Point(0, szImage.cy - 40), cv::Point(szImage.cx, szImage.cy), cv::Scalar(0, 0, 0), cv::FILLED);

		int fontFace = cv::FONT_HERSHEY_TRIPLEX;
		double fontScale = 0.7;
		int thickness = 1;

		CT2CA pszConvertedAnsiTitle(strTitle);
		cv::String strCVTitle(pszConvertedAnsiTitle);
		cv::putText(colorImg, strCVTitle, cv::Point(10, szImage.cy - 10), fontFace, fontScale, CV_RGB(255, 255, 255), thickness);

		CT2CA pszConvertedAnsiFile(strFile);
		cv::String strStdFile(pszConvertedAnsiFile);
		cv::imwrite(strStdFile, colorImg);
		Unlock();
	}
	catch (cv::Exception& e) {
		bSuccess = FALSE;
		Unlock();
		g_pLog->DisplayMessage(_T("OpenCV Exception: %s"), e.what());
	}
	return bSuccess;

#if 0
	IplImage *pImageTmp = cvCreateImage(cvSize(szImage.cx, szImage.cy), 8,1);
	cvZero(pImageTmp);

	// add point to the image
	for (int i = 0; i<szImage.cy; i++)
	{
		for (int j = 0; j<szImage.cx; j++)
		{
			pImageTmp->imageData[i*pImageTmp->widthStep+j] = pDefect->m_Image[i*szImage.cx+j];
		}
	}

	IplImage *pColorImg = cvCreateImage(cvSize(szImage.cx, szImage.cy), 8, 3);
	cvZero(pColorImg);

	cvCvtColor(pImageTmp, pColorImg, CV_GRAY2BGR);

	cvRectangle(pColorImg,CvPoint(rectDefect.left,rectDefect.top), CvPoint(rectDefect.left+rectDefect.Width(),rectDefect.top+rectDefect.Height()), color, 1);

	// Title
	// 1. Draw BackGround
	cvRectangle(pColorImg,CvPoint(0, szImage.cy-40), CvPoint(szImage.cx, szImage.cy), cvScalar(0,0,0), CV_FILLED);

	USES_CONVERSION;

	// 2. Draw Title Text..
	CvFont font;
	cvInitFont(&font, CV_FONT_HERSHEY_TRIPLEX, 0.7, 0.7, 0, 1);

	CString strTitle;
	int nSideIdx = (0 <= pDefect->m_DefectInfo.m_nSideIdx && pDefect->m_DefectInfo.m_nSideIdx < MAX_SIDE_COUNT) ? pDefect->m_DefectInfo.m_nSideIdx : MAX_SIDE_COUNT;
	int nCategoryIdx = (0 <= pDefect->m_DefectInfo.m_DefectLoc && pDefect->m_DefectInfo.m_DefectLoc < DefectLoc_None) ? pDefect->m_DefectInfo.m_DefectLoc : DefectLoc_Unknown;

	strTitle.Format(_T("SIDE[%s] CAT[%s] SIZE[%d,%d]"), g_SideName[nSideIdx], g_strDefectType[nCategoryIdx], (int) pDefect->m_dSizeX_um, (int) pDefect->m_dSizeY_um);
	cvPutText(pColorImg, W2A(strTitle), CvPoint(10, szImage.cy-10), &font, CV_RGB(255,255,255));
	
	char str_filename[1024];
	sprintf_s(str_filename, "%s", W2A(strFile));
	cvSaveImage(str_filename, pColorImg);

	cvReleaseImage(&pColorImg);
	cvReleaseImage(&pImageTmp);

	return TRUE;
#endif
}

void CPostProcess::WriteDefectFile()
{
	g_pLog->DisplayMessage(_T("[Start Defect File...]"));

	CTime tLoadingTime = m_pGlassData->GetLoadingTime();
	CString strLoadingTime = tLoadingTime.Format(_T("%Y%m%d%H%M%S"));

	CString   strDefectFilePath;
	strDefectFilePath.Format(_T("D:\\Defect\\%s\\%s\\%04d\\%02d\\%02d\\%s_%s_%s\\"), m_pHardware->GetMachineName(), m_pHardware->GetLineID()
		, tLoadingTime.GetYear(),tLoadingTime.GetMonth(),tLoadingTime.GetDay()
		, m_pGlassData->GetGlassRecipe()->GetRecipeName(), g_pBase->m_strHPanelID, strLoadingTime);

	CheckDirectory(strDefectFilePath);

	strDefectFilePath.Format(_T("D:\\Defect\\%s\\%s\\%04d\\%02d\\%02d\\%s_%s_%s.csv"), m_pHardware->GetMachineName(), m_pHardware->GetLineID()
		, tLoadingTime.GetYear(),tLoadingTime.GetMonth(),tLoadingTime.GetDay()
		, m_pGlassData->GetGlassRecipe()->GetRecipeName(), g_pBase->m_strHPanelID, strLoadingTime);

	CString strTemp;
	std::vector<CString> vecStrTitle;
	std::vector<CString> vecStrResultData[MAX_DEFECT_COUNT_GLASS];

	CString strPanelID = g_pBase->m_strHPanelID;

	// Title
	vecStrTitle.push_back(_T("TIME"));
	vecStrTitle.push_back(_T("PANEL_ID"));
	vecStrTitle.push_back(_T("SIDE"));
	vecStrTitle.push_back(_T("TYPE"));
	vecStrTitle.push_back(_T("SIZE_X"));
	vecStrTitle.push_back(_T("SIZE_Y"));
	vecStrTitle.push_back(_T("IMG_PATH"));

	MapDefectIt it;
	MapDefect* pMapDefect = m_pGlassData->GetMapDefect_NG();

	if(pMapDefect == NULL)
		return;

	int nDefectCount = 0;

	CString strSideName[MAX_SIDE_COUNT] = {_T("A_UP"),_T("B_UP"),_T("C_UP"),_T("D_UP"),_T("A_DN"),_T("B_DN"),_T("C_DN"),_T("D_DN")};

	for(it=pMapDefect->begin();it!=pMapDefect->end();it++)
	{      
		CDefect* pDefect = static_cast<CDefect*>(it->second);      

		if(pDefect == NULL)
			continue;

		// 1. Time
		vecStrResultData[nDefectCount].push_back(strLoadingTime);

		// 2. PANEL ID
		vecStrResultData[nDefectCount].push_back(strPanelID);

		// 3. SIDE
		vecStrResultData[nDefectCount].push_back(strSideName[pDefect->m_DefectInfo.m_nSideIdx]);

		// 4. TYPE
		vecStrResultData[nDefectCount].push_back(g_strDefectType[(int) pDefect->m_DefectInfo.m_DefectLoc]);

		// 5. SIZE X
		strTemp.Format(_T("%.3f"), pDefect->m_dSizeX_um);
		vecStrResultData[nDefectCount].push_back(strTemp);

		// 6. SIZE Y
		strTemp.Format(_T("%.3f"), pDefect->m_dSizeY_um);
		vecStrResultData[nDefectCount].push_back(strTemp);

		// 7. Image Path
		CString   strSaveImagePath;
		strSaveImagePath.Format(_T("D:\\Inspection\\Defect\\Inspection\\%s\\%s\\%04d\\%02d\\%02d\\%s_%s_%s\\L1_%d.png"), m_pHardware->GetMachineName(), m_pHardware->GetLineID()
			, tLoadingTime.GetYear(),tLoadingTime.GetMonth(),tLoadingTime.GetDay()
			, m_pGlassData->GetGlassRecipe()->GetRecipeName(), g_pBase->m_strHPanelID, tLoadingTime.Format(_T("%Y%m%d%H%M%S")), nDefectCount+1);

		CRect rectDefect;
		rectDefect.left      = DEFECTIMAGE_WIDTH/2   - pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width()/2;
		rectDefect.right   = DEFECTIMAGE_WIDTH/2   + pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width()/2;
		rectDefect.top      = DEFECTIMAGE_HEIGHT/2   - pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height()/2;
		rectDefect.bottom   = DEFECTIMAGE_HEIGHT/2   + pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height()/2;

		SaveDefectImage_with_Title(pDefect, CSize(DEFECTIMAGE_WIDTH,DEFECTIMAGE_HEIGHT), rectDefect, strSaveImagePath);

		vecStrResultData[nDefectCount].push_back(strSaveImagePath);

		nDefectCount++;
	}

	g_pLog->DisplayMessage(_T("End of Save Defect Image NG.."));


	CFile _File;
	CFileException _Exception;
	_File.Open(strDefectFilePath, CFile::modeCreate|CFile::modeWrite|CFile::modeNoTruncate|CFile::shareDenyWrite|CFile::shareDenyRead, &_Exception);

	if(_Exception.m_cause == CFileException::none)
	{
		USES_CONVERSION;
		int nBufferSize = vecStrTitle.size() * 255 * (nDefectCount + 1);
		char* strBuffer = new char[nBufferSize];
		int nBufferIdx = 0;

		if(_File.SeekToEnd() == 0L)
		{
			ZeroMemory(strBuffer, sizeof(nBufferSize));

			for(int i=0; i<vecStrTitle.size()-1; i++)
			{
				sprintf(&strBuffer[nBufferIdx], "%s,", W2A(vecStrTitle[i]));
				nBufferIdx += vecStrTitle[i].GetLength() + 1;
			}

			sprintf(&strBuffer[nBufferIdx], "%s\r\n", W2A(vecStrTitle[vecStrTitle.size()-1]));
			nBufferIdx += vecStrTitle[vecStrTitle.size()-1].GetLength() + 2;

			_File.Write(strBuffer, nBufferIdx);
		}

		ZeroMemory(strBuffer, sizeof(nBufferSize));
		nBufferIdx = 0;

		for(int nDefectIdx = 0; nDefectIdx < nDefectCount; nDefectIdx++)
		{
			std::vector<CString>* pVecResult = &vecStrResultData[nDefectIdx];

			if(pVecResult == NULL)
				continue;

			for(int i=0; i<pVecResult->size()-1; i++)
			{
				sprintf(&strBuffer[nBufferIdx], "%s,", W2A((*pVecResult)[i]));
				nBufferIdx += (*pVecResult)[i].GetLength() + 1;
			}

			sprintf(&strBuffer[nBufferIdx], "%s\r\n", W2A((*pVecResult)[pVecResult->size()-1]));
			nBufferIdx += (*pVecResult)[pVecResult->size()-1].GetLength() + 2;
		}

		_File.Write(strBuffer, nBufferIdx);

		delete [] strBuffer;
	}
	_File.Close();

	g_pLog->DisplayMessage(_T("[End Data File...] %s"), strDefectFilePath);

}

void CPostProcess::WriteMapFile()
{

}

void CPostProcess::WriteDataFile()
{
	g_pLog->DisplayMessage(_T("[Start Data File...]"));

	CString strTemp;
	std::vector<CString> vecStrTitle;
	std::vector<CString> vecStrResultData;

	// 1. Loading Time
	CTime tLoadingTime = m_pGlassData->GetLoadingTime();
	strTemp = tLoadingTime.Format(_T("%Y%m%d%H%M%S"));
	vecStrTitle.push_back(_T("TIME"));
	vecStrResultData.push_back(strTemp);

	// 2. Panel ID
	vecStrTitle.push_back(_T("PANEL_ID"));
	vecStrResultData.push_back(g_pBase->m_strHPanelID);

	DimensionDir arryWriteOrder_UP[MAX_PANEL_SIDE] = {DIMENSION_A, DIMENSION_B, DIMENSION_C, DIMENSION_D};
	DimensionDir arryWriteOrder_DN[MAX_PANEL_SIDE] = {DIMENSION_A_DN, DIMENSION_B_DN, DIMENSION_C_DN, DIMENSION_D_DN};
	CString arrStrSideName[MAX_PANEL_SIDE] = {_T("A"), _T("B"), _T("C"), _T("D")};

	// 3. Corner

	
	// A 惑何 官蹿
	vecStrTitle.push_back(_T("CORNER_1_X"));
	strTemp.Format(_T("%d"), m_pGlassData->GetSideData(DIMENSION_A)->m_nBottomCornerWidth);
	vecStrResultData.push_back(strTemp);
	vecStrTitle.push_back(_T("CORNER_1_Y"));
	strTemp.Format(_T("%d"), m_pGlassData->GetSideData(DIMENSION_A)->m_nBottomCornerHeight);
	vecStrResultData.push_back(strTemp);

	// C 惑何 官蹿
	vecStrTitle.push_back(_T("CORNER_2_X"));
	strTemp.Format(_T("%d"), m_pGlassData->GetSideData(DIMENSION_C)->m_nBottomCornerWidth);
	vecStrResultData.push_back(strTemp);
	vecStrTitle.push_back(_T("CORNER_2_Y"));
	strTemp.Format(_T("%d"), m_pGlassData->GetSideData(DIMENSION_C)->m_nBottomCornerHeight);
	vecStrResultData.push_back(strTemp);

	// C 惑何 啪
	vecStrTitle.push_back(_T("CORNER_3_X"));
	strTemp.Format(_T("%d"), m_pGlassData->GetSideData(DIMENSION_C)->m_nTopCornerWidth);
	vecStrResultData.push_back(strTemp);
	vecStrTitle.push_back(_T("CORNER_3_Y"));
	strTemp.Format(_T("%d"), m_pGlassData->GetSideData(DIMENSION_C)->m_nTopCornerHeight);
	vecStrResultData.push_back(strTemp);

	// A 惑何 啪
	vecStrTitle.push_back(_T("CORNER_4_X"));
	strTemp.Format(_T("%d"), m_pGlassData->GetSideData(DIMENSION_A)->m_nTopCornerWidth);
	vecStrResultData.push_back(strTemp);
	vecStrTitle.push_back(_T("CORNER_4_Y"));
	strTemp.Format(_T("%d"), m_pGlassData->GetSideData(DIMENSION_A)->m_nTopCornerHeight);
	vecStrResultData.push_back(strTemp);

	// 4. Side Result
	for(int nSideIdx=0; nSideIdx<MAX_PANEL_SIDE; nSideIdx++)
	{
		CSide_Data* pSideData_UP = m_pGlassData->GetSideData(arryWriteOrder_UP[nSideIdx]);
		CSide_Data* pSideData_DN = m_pGlassData->GetSideData(arryWriteOrder_DN[nSideIdx]);

		// 4-1. Panel Size
		strTemp.Format(_T("SIZE_%s"), arrStrSideName[nSideIdx]);
		vecStrTitle.push_back(strTemp);
		double dPanelSize = (pSideData_UP->m_nGlassEndLine - pSideData_UP->m_nGlassStartLine) * pSideData_UP->m_dPixelSizeY;
		strTemp.Format(_T("%.3f"), dPanelSize);
		vecStrResultData.push_back(strTemp);

		// 4-2. Dimension
		for(int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_DIMENSION_MEASURE_COUNT; nMeasureIdx++)
		{
			strTemp.Format(_T("%s_DIM_%d"), arrStrSideName[nSideIdx], nMeasureIdx+1);
			vecStrTitle.push_back(strTemp);

			double dDimension = pSideData_UP->m_dSideMeasrue_CutLine_Result_mm[nMeasureIdx];
			strTemp.Format(_T("%.0f"), dDimension*1000.0);
			vecStrResultData.push_back(strTemp);
		}

		// 4-3. Up Chamfer
		for(int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_DIMENSION_MEASURE_COUNT; nMeasureIdx++)
		{
			strTemp.Format(_T("%s_UP_CHAM_%d"), arrStrSideName[nSideIdx], nMeasureIdx+1);
			vecStrTitle.push_back(strTemp);

			double dChamfer = pSideData_UP->m_dSideMeasrue_Chamfer_Result_mm[nMeasureIdx];
			strTemp.Format(_T("%.0f"), dChamfer*1000.0);
			vecStrResultData.push_back(strTemp);
		}

		// 4-4. Dn Chamfer
		for(int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_DIMENSION_MEASURE_COUNT; nMeasureIdx++)
		{
			strTemp.Format(_T("%s_DN_CHAM_%d"), arrStrSideName[nSideIdx], nMeasureIdx+1);
			vecStrTitle.push_back(strTemp);

			double dChamfer = pSideData_DN->m_dSideMeasrue_Chamfer_Result_mm[nMeasureIdx];
			strTemp.Format(_T("%.0f"), dChamfer*1000.0);
			vecStrResultData.push_back(strTemp);
		}
	}

	// 5. Notch
	CSide_Data* pSideData_UP = NULL;
	CSide_Data* pSideData_DN = NULL;

	// Notch乐绰 搁 茫扁
	for(int nSideIdx=0; nSideIdx<MAX_PANEL_SIDE; nSideIdx++)
	{
		pSideData_UP = m_pGlassData->GetSideData(arryWriteOrder_UP[nSideIdx]);
		pSideData_DN = m_pGlassData->GetSideData(arryWriteOrder_DN[nSideIdx]);

		if(pSideData_DN->m_nNotchCount != 0)
			break;
	}

	for(int nNotchIdx=0; nNotchIdx<MAX_SIDE_NOTCH_COUNT; nNotchIdx++)
	{
		// 4-2. Dimension, 酒阀搁栏肺 螟沥
		for(int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_NOTCH_MEASURE_COUNT; nMeasureIdx++)
		{
			strTemp.Format(_T("NOTCH_%d_DIM_%d"), nNotchIdx+1, nMeasureIdx+1);
			vecStrTitle.push_back(strTemp);

			double dDimension = pSideData_DN->m_dNotch_Dimension_Edge_Result_um[nNotchIdx][nMeasureIdx];
			strTemp.Format(_T("%.0f"), dDimension);
			vecStrResultData.push_back(strTemp);
		}

		// 4-3. Up Chamfer
		for(int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_NOTCH_MEASURE_COUNT; nMeasureIdx++)
		{
			strTemp.Format(_T("NOTCH_%d_UP_CHAM_%d"), nNotchIdx+1, nMeasureIdx+1);
			vecStrTitle.push_back(strTemp);

			double dChamfer = pSideData_UP->m_dNotch_Chamfer_Edge_Result_um[nNotchIdx][nMeasureIdx];
			strTemp.Format(_T("%.0f"), dChamfer);
			vecStrResultData.push_back(strTemp);
		}

		// 4-4. Dn Chamfer
		for(int nMeasureIdx = 0; nMeasureIdx < MAX_SIDE_NOTCH_MEASURE_COUNT; nMeasureIdx++)
		{
			strTemp.Format(_T("NOTCH_%d_DN_CHAM_%d"), nNotchIdx+1, nMeasureIdx+1);
			vecStrTitle.push_back(strTemp);

			double dChamfer = pSideData_DN->m_dNotch_Chamfer_Edge_Result_um[nNotchIdx][nMeasureIdx];
			strTemp.Format(_T("%.0f"), dChamfer);
			vecStrResultData.push_back(strTemp);
		}
	}

	// Save Path
	CString strFilePath;
	if (m_pHardware->m_bSaveResultByHour) {
		// 按小时保存，绑定玻璃 Loading Time
		strFilePath.Format(_T("D:\\Data\\%s\\%s\\%d\\%02d\\%02d\\%s_%s_%02d.csv"),
			m_pHardware->GetMachineName(),
			m_pHardware->GetLineID(),
			tLoadingTime.GetYear(),
			tLoadingTime.GetMonth(),
			tLoadingTime.GetDay(),
			g_pBase->m_strRecipeName,
			g_pBase->m_strLoadingDay,
			tLoadingTime.GetHour());
	}
	else {
		// 按天保存，绑定玻璃 Loading Time
		strFilePath.Format(_T("D:\\Data\\%s\\%s\\%d\\%02d\\%02d\\%s_%s.csv"),
			m_pHardware->GetMachineName(),
			m_pHardware->GetLineID(),
			tLoadingTime.GetYear(),
			tLoadingTime.GetMonth(),
			tLoadingTime.GetDay(),
			g_pBase->m_strRecipeName,
			g_pBase->m_strLoadingDay);
	}

	CheckDirectory(strFilePath);

	CFile _File;
	CFileException _Exception;
	_File.Open(strFilePath, CFile::modeCreate|CFile::modeWrite|CFile::modeNoTruncate|CFile::shareDenyWrite|CFile::shareDenyRead, &_Exception);

	if(_Exception.m_cause == CFileException::none)
	{
		USES_CONVERSION;
		int nBufferSize = vecStrTitle.size() * 255;
		char* strBuffer = new char[nBufferSize];
		int nBufferIdx = 0;

		if(_File.SeekToEnd() == 0L)
		{
			ZeroMemory(strBuffer, sizeof(nBufferSize));

			for(int i=0; i<vecStrTitle.size()-1; i++)
			{
				sprintf(&strBuffer[nBufferIdx], "%s,", W2A(vecStrTitle[i]));
				nBufferIdx += vecStrTitle[i].GetLength() + 1;
			}

			sprintf(&strBuffer[nBufferIdx], "%s\r\n", W2A(vecStrTitle[vecStrTitle.size()-1]));
			nBufferIdx += vecStrTitle[vecStrTitle.size()-1].GetLength() + 2;

			_File.Write(strBuffer, nBufferIdx);
		}

		ZeroMemory(strBuffer, sizeof(nBufferSize));
		nBufferIdx = 0;

		for(int i=0; i<vecStrResultData.size()-1; i++)
		{
			sprintf(&strBuffer[nBufferIdx], "%s,", W2A(vecStrResultData[i]));
			nBufferIdx += vecStrResultData[i].GetLength() + 1;
		}

		sprintf(&strBuffer[nBufferIdx], "%s\r\n", W2A(vecStrResultData[vecStrResultData.size()-1]));
		nBufferIdx += vecStrResultData[vecStrResultData.size()-1].GetLength() + 2;

		_File.Write(strBuffer, nBufferIdx);

		delete [] strBuffer;
	}
	_File.Close();

	CString strDmyFilePath;
	strDmyFilePath.Format(_T("%s.dmy"), strFilePath);
	CFile _File_Dmy;
	CFileException _Exception_Dmy;
	_File_Dmy.Open(strDmyFilePath, CFile::modeCreate|CFile::modeWrite|CFile::modeNoTruncate|CFile::shareDenyWrite|CFile::shareDenyRead, &_Exception_Dmy);
	_File_Dmy.Close();

	g_pLog->DisplayMessage(_T("[End Data File...] %s"), strFilePath);
}

BOOL CPostProcess::DefectProcess_Judge(CDefect *pDefect)
{
	if(pDefect == NULL)
		return FALSE;

	int nSide = pDefect->m_DefectInfo.m_nSideIdx;

	if(nSide < 0 || MAX_SIDE_COUNT <= nSide)
		return FALSE;

	CSIDE_PARM* pSideParam = &m_pRecipe->m_SideParam[nSide];
	CSIDE_INSPECTT_PARM * pSideInsParam = NULL;

	CSide_Data* pSideData = m_pGlassData->GetSideData((DimensionDir) nSide);

	BOOL bJudgeUse = FALSE;
	int nJudgeW_um = 0;
	int nJudgeH_um = 0;
	BOOL bAnd = TRUE;

	int nJudgeArea = pDefect->m_nJudgeArea;

	switch(pDefect->m_DefectInfo.m_DefectLoc)
	{
	case DefectLoc_Chip:
		pSideInsParam		= &pSideParam->m_InspectPrm[(int) eSideInsType_Chip];
		nJudgeW_um			= pSideInsParam->m_nJudge_Size_Min_X_um[nJudgeArea];
		nJudgeH_um			= pSideInsParam->m_nJudge_Size_Min_Y_um[nJudgeArea];
		bAnd				= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 2) ? TRUE : FALSE;
		bJudgeUse			= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_Crack:
		pSideInsParam		= &pSideParam->m_InspectPrm[(int) eSideInsType_Crack];
		nJudgeW_um			= pSideInsParam->m_nJudge_Size_Min_X_um[nJudgeArea];
		nJudgeH_um			= pSideInsParam->m_nJudge_Size_Min_Y_um[nJudgeArea];
		bAnd				= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 2) ? TRUE : FALSE;
		bJudgeUse			= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_Burr:
		pSideInsParam		= &pSideParam->m_InspectPrm[(int) eSideInsType_Burr];
		nJudgeW_um			= pSideInsParam->m_nJudge_Size_Min_X_um[nJudgeArea];
		nJudgeH_um			= pSideInsParam->m_nJudge_Size_Min_Y_um[nJudgeArea];
		bAnd				= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 2) ? TRUE : FALSE;
		bJudgeUse			= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_Chamfer:
		pSideInsParam		= &pSideParam->m_InspectPrm[(int) eSideInsType_Chamfer];
		nJudgeW_um			= pSideInsParam->m_nJudge_Size_Min_X_um[nJudgeArea];
		nJudgeH_um			= pSideInsParam->m_nJudge_Size_Min_Y_um[nJudgeArea];
		bAnd				= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 2) ? TRUE : FALSE;
		bJudgeUse			= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_In_Chip: 
		pSideInsParam		= &pSideParam->m_InspectPrm[(int) eSideInsType_In_Chip];
		nJudgeW_um			= pSideInsParam->m_nJudge_Size_Min_X_um[nJudgeArea];
		nJudgeH_um			= pSideInsParam->m_nJudge_Size_Min_Y_um[nJudgeArea];
		bAnd				= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 2) ? TRUE : FALSE;
		bJudgeUse			= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_In_Crack:
		pSideInsParam		= &pSideParam->m_InspectPrm[(int) eSideInsType_In_Crack];
		nJudgeW_um			= pSideInsParam->m_nJudge_Size_Min_X_um[nJudgeArea];
		nJudgeH_um			= pSideInsParam->m_nJudge_Size_Min_Y_um[nJudgeArea];
		bAnd				= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 2) ? TRUE : FALSE;
		bJudgeUse			= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_In_Burr:
		pSideInsParam		= &pSideParam->m_InspectPrm[(int) eSideInsType_In_Burr];
		nJudgeW_um			= pSideInsParam->m_nJudge_Size_Min_X_um[nJudgeArea];
		nJudgeH_um			= pSideInsParam->m_nJudge_Size_Min_Y_um[nJudgeArea];
		bAnd				= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 2) ? TRUE : FALSE;
		bJudgeUse			= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_In_Chamfer:
		pSideInsParam		= &pSideParam->m_InspectPrm[(int) eSideInsType_In_Chamfer];
		nJudgeW_um			= pSideInsParam->m_nJudge_Size_Min_X_um[nJudgeArea];
		nJudgeH_um			= pSideInsParam->m_nJudge_Size_Min_Y_um[nJudgeArea];
		bAnd				= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 2) ? TRUE : FALSE;
		bJudgeUse			= (pSideInsParam->m_nJudge_Size_Min_OR_AND[nJudgeArea] == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_Top_Corner:
		nJudgeW_um		= pSideParam->m_nTopCorner_Judge_Size_Min_X_um;
		nJudgeH_um		= pSideParam->m_nTopCorner_Judge_Size_Min_Y_um;
		bAnd			= (pSideParam->m_nTopCorner_Judge_Size_Min_OR_AND == 2) ? TRUE : FALSE;
		bJudgeUse		= (pSideParam->m_nTopCorner_Judge_Size_Min_OR_AND == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_Bot_Corner:
		nJudgeW_um		= pSideParam->m_nBottomCorner_Judge_Size_Min_X_um;
		nJudgeH_um		= pSideParam->m_nBottomCorner_Judge_Size_Min_Y_um;
		bAnd			= (pSideParam->m_nBottomCorner_Judge_Size_Min_OR_AND == 2) ? TRUE : FALSE;
		bJudgeUse		= (pSideParam->m_nBottomCorner_Judge_Size_Min_OR_AND == 0) ? FALSE : TRUE;	
		break;
	case DefectLoc_UserDefect:
		nJudgeW_um		= pSideParam->m_UserDefectPrm[pDefect->m_nUserDefectAreaIdx].m_nJudge_Size_Min_X_um;
		nJudgeH_um		= pSideParam->m_UserDefectPrm[pDefect->m_nUserDefectAreaIdx].m_nJudge_Size_Min_Y_um;
		bAnd			= (pSideParam->m_UserDefectPrm[pDefect->m_nUserDefectAreaIdx].m_nJudge_Size_Min_OR_AND == 2) ? TRUE : FALSE;
		bJudgeUse		= (pSideParam->m_UserDefectPrm[pDefect->m_nUserDefectAreaIdx].m_nJudge_Size_Min_OR_AND == 0) ? FALSE : TRUE;
		break;
	case DefectLoc_Notch_Crack:
		
	case DefectLoc_Notch_NoGrind:
		nJudgeW_um = pSideParam->m_NotchPrm[pDefect->m_nNotchIdx].m_nNotch_Inspect_Defect_Judge_X_um;
		nJudgeH_um = pSideParam->m_NotchPrm[pDefect->m_nNotchIdx].m_nNotch_Inspect_Defect_Judge_Y_um;
		bAnd = (pSideParam->m_NotchPrm[pDefect->m_nNotchIdx].m_nNotch_Inspect_Defect_Judge_And == 2) ? TRUE : FALSE;
		bJudgeUse = (pSideParam->m_NotchPrm[pDefect->m_nNotchIdx].m_nNotch_Inspect_Defect_Judge_And == 0) ? FALSE : TRUE;
		break;
	case DefectLoc_Exception:
		return TRUE;
	}

	if(bJudgeUse == FALSE)
	{
		pDefect->m_bJudge_NG = TRUE;
		return TRUE;
	}

	if(bAnd == TRUE)
	{
		if((double)pDefect->m_dSizeX_um >= nJudgeW_um && (double)pDefect->m_dSizeY_um >= nJudgeH_um)
			pDefect->m_bJudge_NG = TRUE;
	}
	else
	{
		if((double)pDefect->m_dSizeX_um >= nJudgeW_um || (double)pDefect->m_dSizeY_um >= nJudgeH_um)
			pDefect->m_bJudge_NG = TRUE;
	}

	return TRUE;
}

void CPostProcess::PostDefectJudgeProcess()
{
	g_pLog->DisplayMessage(_T("Post Defect Judge Procss.."));

	if(m_pRecipe == NULL || m_pHardware == NULL)
		return;

	CHardwareSettings* pHard = m_pHardware;

	CCameraSettings* pCamera[MAX_CAMERA_COUNT][MAX_SCAN_COUNT] = {};

	for(int i=0; i<MAX_CAMERA_COUNT; i++)
		for(int j=0; j<MAX_SCAN_COUNT; j++)
			pCamera[i][j] = m_pHardware->GetCameraSettings(i, j);

	double dScanRes = 0.;
	double dConvRes = 0.;

	int nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

	CDefect* pDefect = NULL;

	for(int iCam=0; iCam<pHard->GetCameraCount(); iCam++)	
	{
		int nCamDefectCount = m_pInspectCamera[iCam]->GetDefectCount();
		g_pLog->DisplayMessage(_T("[%d]Camera Defect Count : %d"), iCam, nCamDefectCount);

		for(int iDefect=0; iDefect < nCamDefectCount ; iDefect++)
		{
			pDefect = m_pInspectCamera[iCam]->GetDefect(iDefect);

			if(pDefect == NULL)
				continue;

			if(m_pGlassData->GetTotalDefectCount() >= MAX_DEFECT_COUNT_GLASS)
				continue;

			int nCamIdx = (pDefect->m_DefectInfo.m_nCamID < 0 || MAX_CAMERA_COUNT <= pDefect->m_DefectInfo.m_nCamID) ? 0 : pDefect->m_DefectInfo.m_nCamID;
			int nScanIdx = (pDefect->m_DefectInfo.m_nScanIdx < 0 || MAX_SCAN_COUNT <= pDefect->m_DefectInfo.m_nScanIdx) ? 0 : pDefect->m_DefectInfo.m_nScanIdx;

			if(pCamera[nCamIdx][nScanIdx] == NULL)	
				continue;		

			dScanRes = pCamera[nCamIdx][nScanIdx]->m_dScanResolution[nStageNo];
			dConvRes = pCamera[nCamIdx][nScanIdx]->m_dConvResolution[nStageNo];

			if (dScanRes <= 0.0 || dConvRes <= 0.0)	
				continue;

			if(DefectProcess(pDefect, m_pInspectCamera[iCam], pCamera[nCamIdx][nScanIdx]) == FALSE)
				continue;

			if(DefectProcess_Judge(pDefect) == FALSE)
				continue;

			CDefect* pNewDefect = new CDefect;
			*(pNewDefect) = *(pDefect);

			if(m_pGlassData->SetDefect(pNewDefect) == FALSE)
			{						
				delete pNewDefect;
				continue;
			}
		}
	}

	g_pLog->DisplayMessage(_T("End of Post Defect Judge Procss.."));
}

void CPostProcess::SaveDefectImageNG()
{
	g_pLog->DisplayMessage(_T("Save Defect Image NG.."));

	if(m_pGlassData == NULL)
		return;

	MapDefectIt it;
	MapDefect* pMapDefect = m_pGlassData->GetMapDefect_NG();

	if(pMapDefect == NULL || 0 == pMapDefect->size())
		return;

	int nMaxChipSaveCount = 0;
	int nMaxCrackSaveCount = 0;
	int nMaxBurrSaveCount = 0;
	int nMaxChamferSaveCount = 0;
	int nMaxInChipSaveCount = 0;
	int nMaxInCrackSaveCount = 0;
	int nMaxInBurrSaveCount = 0;
	int nMaxInChamferSaveCount = 0;
	int nMaxTopCornerSaveCount = 0;
	int nMaxBotCornerSaveCount = 0;
	int nMaxCornerDimensionSaveCount = 0;
	int nMaxDimensionSaveCount = 0;
	int nMaxNotchSaveCount = 0;
	int nMaxNotchDimensionSaveCount = 0;
	int nMaxNotchChamferSaveCount = 0;
	int nMaxNotchRadiusSaveCount = 0;
	int nMaxUserDefectSaveCount = 0;
	int nMaxMarkSaveCount = 0;
	int nMaxExceptionSaveCount = 0;
	int nMaxLicenseSaveCount = 0;
	for (it = pMapDefect->begin(); it != pMapDefect->end(); it++)
	{
		if (0 == pMapDefect->size()) break;

		CDefect* pDefect = static_cast<CDefect*>(it->second);		
		if(pDefect == NULL)
			continue;
		if(pDefect->m_DefectInfo.m_DefectLoc < DefectLoc_Chip || pDefect->m_DefectInfo.m_DefectLoc > DefectLoc_None)
			continue;
		if(pDefect->m_DefectInfo.m_nSideIdx < 0 || pDefect->m_DefectInfo.m_nSideIdx >= MAX_DIMENSION_COUNT)
			continue;

		CString strDefectType = g_strDefectType[pDefect->m_DefectInfo.m_DefectLoc];
		if (strDefectType.Compare(_T("Chip")) == 0 && g_pBase->m_nMaxChipSaveCount != 0)
		{
			nMaxChipSaveCount++;
			if (nMaxChipSaveCount > g_pBase->m_nMaxChipSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Crack")) == 0 && g_pBase->m_nMaxCrackSaveCount != 0)
		{
			nMaxCrackSaveCount++;
			if (nMaxCrackSaveCount > g_pBase->m_nMaxCrackSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Burr")) == 0 && g_pBase->m_nMaxBurrSaveCount != 0)
		{
			nMaxBurrSaveCount++;
			if (nMaxBurrSaveCount > g_pBase->m_nMaxBurrSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Chamfer")) == 0 && g_pBase->m_nMaxChamferSaveCount != 0)
		{
			nMaxChamferSaveCount++;
			if (nMaxChamferSaveCount > g_pBase->m_nMaxChamferSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("In_Chip")) == 0 && g_pBase->m_nMaxInChipSaveCount != 0)
		{
			nMaxInChipSaveCount;
			if (nMaxInChipSaveCount > g_pBase->m_nMaxInChipSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("In_Crack")) == 0 && g_pBase->m_nMaxInCrackSaveCount != 0)
		{
			nMaxInCrackSaveCount++;
			if (nMaxInCrackSaveCount > g_pBase->m_nMaxInCrackSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("In_Burr")) == 0 && g_pBase->m_nMaxInBurrSaveCount != 0)
		{
			nMaxInBurrSaveCount++;
			if (nMaxInBurrSaveCount > g_pBase->m_nMaxInBurrSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("In_Chamfer")) == 0 && g_pBase->m_nMaxInChamferSaveCount != 0)
		{
			nMaxInChamferSaveCount++;
			if (nMaxInChamferSaveCount > g_pBase->m_nMaxInChamferSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Top_Corner")) == 0 && g_pBase->m_nMaxTopCornerSaveCount != 0)
		{
			nMaxTopCornerSaveCount++;
			if (nMaxTopCornerSaveCount > g_pBase->m_nMaxTopCornerSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Bot_Corner")) == 0 && g_pBase->m_nMaxBotCornerSaveCount != 0)
		{
			nMaxBotCornerSaveCount++;
			if (nMaxBotCornerSaveCount > g_pBase->m_nMaxBotCornerSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Corner_Dimension")) == 0 && g_pBase->m_nMaxCornerDimensionSaveCount != 0)
		{
			nMaxCornerDimensionSaveCount++;
			if (nMaxCornerDimensionSaveCount > g_pBase->m_nMaxCornerDimensionSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Dimension")) == 0 && g_pBase->m_nMaxDimensionSaveCount != 0)
		{
			nMaxDimensionSaveCount++;
			if (nMaxDimensionSaveCount > g_pBase->m_nMaxDimensionSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Notch")) == 0 && g_pBase->m_nMaxNotchSaveCount != 0)
		{
			nMaxNotchSaveCount++;
			if (nMaxNotchSaveCount > g_pBase->m_nMaxNotchSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Notch_Dimension")) == 0 && g_pBase->m_nMaxNotchDimensionSaveCount != 0)
		{
			nMaxNotchDimensionSaveCount++;
			if (nMaxNotchDimensionSaveCount > g_pBase->m_nMaxNotchDimensionSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Notch_Chamfer")) == 0 && g_pBase->m_nMaxNotchChamferSaveCount != 0)
		{
			nMaxNotchChamferSaveCount++;
			if (nMaxNotchChamferSaveCount > g_pBase->m_nMaxNotchChamferSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Notch_Radius")) == 0 && g_pBase->m_nMaxNotchRadiusSaveCount != 0)
		{
			nMaxNotchRadiusSaveCount++;
			if (nMaxNotchRadiusSaveCount > g_pBase->m_nMaxNotchRadiusSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("User_Defect")) == 0 && g_pBase->m_nMaxUserDefectSaveCount != 0)
		{
			nMaxUserDefectSaveCount++;
			if (nMaxUserDefectSaveCount > g_pBase->m_nMaxUserDefectSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Mark")) == 0 && g_pBase->m_nMaxMarkSaveCount != 0)
		{
			nMaxMarkSaveCount++;
			if (nMaxMarkSaveCount > g_pBase->m_nMaxMarkSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Exception")) == 0 && g_pBase->m_nMaxExceptionSaveCount != 0)
		{
			nMaxExceptionSaveCount++;
			if (nMaxExceptionSaveCount > g_pBase->m_nMaxExceptionSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("License")) == 0 && g_pBase->m_nMaxLicenseSaveCount != 0)
		{
			nMaxLicenseSaveCount++;
			if (nMaxLicenseSaveCount > g_pBase->m_nMaxLicenseSaveCount) continue;
		}

		CString strSaveImagePath;
		//strSaveImagePath.Format(_T("%s\\%03d_%s_%s_%s.jpg"),m_strDefectFolder,pNewDefect->m_nIdx, g_pBase->m_strHPanelID, PANEL_SIDE[pNewDefect->m_DefectInfo.m_nSideIdx], strDefectType);
		strSaveImagePath.Format(_T("%s\\%s_%s_%s_%d.jpg"),m_strDefectFolder, g_pBase->m_strHPanelID, PANEL_SIDE[pDefect->m_DefectInfo.m_nSideIdx], strDefectType, pDefect->m_nIdx);

		CRect rectDefect;
		rectDefect.left		= DEFECTIMAGE_WIDTH/2	- pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width()/2;
		rectDefect.right	= DEFECTIMAGE_WIDTH/2	+ pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width()/2;
		rectDefect.top		= DEFECTIMAGE_HEIGHT/2	- pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height()/2;
		rectDefect.bottom	= DEFECTIMAGE_HEIGHT/2	+ pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height()/2;

		CheckDirectory(strSaveImagePath);
		// SaveDefectImage2(pNewDefect->m_Image,CSize(DEFECTIMAGE_WIDTH,DEFECTIMAGE_HEIGHT), rectDefect, strSaveImagePath);
		SaveDefectImage_with_Title(pDefect, CSize(DEFECTIMAGE_WIDTH,DEFECTIMAGE_HEIGHT), rectDefect, strSaveImagePath);

		pDefect->m_strSaveImagePath = strSaveImagePath;
	}

	g_pLog->DisplayMessage(_T("End of Save Defect Image NG.."));
}

void CPostProcess::SaveDefectImageOK()
{
	g_pLog->DisplayMessage(_T("Save Defect Image OK.."));

	if (m_pGlassData == NULL)
		return;

	Lock();
	MapDefectIt it;
	MapDefect* pMapDefect = m_pGlassData->GetMapDefect_OK();
	Unlock();

	if (pMapDefect == NULL || 0 == pMapDefect->size())
		return;

	int nMaxChipSaveCount = 0;
	int nMaxCrackSaveCount = 0;
	int nMaxBurrSaveCount = 0;
	int nMaxChamferSaveCount = 0;
	int nMaxInChipSaveCount = 0;
	int nMaxInCrackSaveCount = 0;
	int nMaxInBurrSaveCount = 0;
	int nMaxInChamferSaveCount = 0;
	int nMaxTopCornerSaveCount = 0;
	int nMaxBotCornerSaveCount = 0;
	int nMaxCornerDimensionSaveCount = 0;
	int nMaxDimensionSaveCount = 0;
	int nMaxNotchSaveCount = 0;
	int nMaxNotchDimensionSaveCount = 0;
	int nMaxNotchChamferSaveCount = 0;
	int nMaxNotchRadiusSaveCount = 0;
	int nMaxUserDefectSaveCount = 0;
	int nMaxMarkSaveCount = 0;
	int nMaxExceptionSaveCount = 0;
	int nMaxLicenseSaveCount = 0;
	for (it = pMapDefect->begin(); it != pMapDefect->end(); it++)
	{
		if (0 == pMapDefect->size()) break;

		CDefect* pDefect = static_cast<CDefect*>(it->second);
		if (pDefect == NULL)
			continue;
		if (pDefect->m_DefectInfo.m_nSideIdx < 0 || pDefect->m_DefectInfo.m_nSideIdx >= MAX_DIMENSION_COUNT)
			continue;
		if (pDefect->m_DefectInfo.m_DefectLoc != DefectLoc_Chip
			&& pDefect->m_DefectInfo.m_DefectLoc != DefectLoc_In_Chip)
			continue;

		CString strDefectFolder;
		strDefectFolder.Format(_T("%s\\IMG_DEFECT_OK\\%s\\%s"), PATH_INSPECTION_DATA, g_pBase->m_strLoadingDay, g_pBase->m_strHPanelID);

		CString strDefectType = g_strDefectType[pDefect->m_DefectInfo.m_DefectLoc];
		if (strDefectType.Compare(_T("Chip")) == 0 && g_pBase->m_nMaxChipSaveCount != 0)
		{
			nMaxChipSaveCount++;
			if (nMaxChipSaveCount > g_pBase->m_nMaxChipSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Crack")) == 0 && g_pBase->m_nMaxCrackSaveCount != 0)
		{
			nMaxCrackSaveCount++;
			if (nMaxCrackSaveCount > g_pBase->m_nMaxCrackSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Burr")) == 0 && g_pBase->m_nMaxBurrSaveCount != 0)
		{
			nMaxBurrSaveCount++;
			if (nMaxBurrSaveCount > g_pBase->m_nMaxBurrSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Chamfer")) == 0 && g_pBase->m_nMaxChamferSaveCount != 0)
		{
			nMaxChamferSaveCount++;
			if (nMaxChamferSaveCount > g_pBase->m_nMaxChamferSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("In_Chip")) == 0 && g_pBase->m_nMaxInChipSaveCount != 0)
		{
			nMaxInChipSaveCount;
			if (nMaxInChipSaveCount > g_pBase->m_nMaxInChipSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("In_Crack")) == 0 && g_pBase->m_nMaxInCrackSaveCount != 0)
		{
			nMaxInCrackSaveCount++;
			if (nMaxInCrackSaveCount > g_pBase->m_nMaxInCrackSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("In_Burr")) == 0 && g_pBase->m_nMaxInBurrSaveCount != 0)
		{
			nMaxInBurrSaveCount++;
			if (nMaxInBurrSaveCount > g_pBase->m_nMaxInBurrSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("In_Chamfer")) == 0 && g_pBase->m_nMaxInChamferSaveCount != 0)
		{
			nMaxInChamferSaveCount++;
			if (nMaxInChamferSaveCount > g_pBase->m_nMaxInChamferSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Top_Corner")) == 0 && g_pBase->m_nMaxTopCornerSaveCount != 0)
		{
			nMaxTopCornerSaveCount++;
			if (nMaxTopCornerSaveCount > g_pBase->m_nMaxTopCornerSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Bot_Corner")) == 0 && g_pBase->m_nMaxBotCornerSaveCount != 0)
		{
			nMaxBotCornerSaveCount++;
			if (nMaxBotCornerSaveCount > g_pBase->m_nMaxBotCornerSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Corner_Dimension")) == 0 && g_pBase->m_nMaxCornerDimensionSaveCount != 0)
		{
			nMaxCornerDimensionSaveCount++;
			if (nMaxCornerDimensionSaveCount > g_pBase->m_nMaxCornerDimensionSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Dimension")) == 0 && g_pBase->m_nMaxDimensionSaveCount != 0)
		{
			nMaxDimensionSaveCount++;
			if (nMaxDimensionSaveCount > g_pBase->m_nMaxDimensionSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Notch")) == 0 && g_pBase->m_nMaxNotchSaveCount != 0)
		{
			nMaxNotchSaveCount++;
			if (nMaxNotchSaveCount > g_pBase->m_nMaxNotchSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Notch_Dimension")) == 0 && g_pBase->m_nMaxNotchDimensionSaveCount != 0)
		{
			nMaxNotchDimensionSaveCount++;
			if (nMaxNotchDimensionSaveCount > g_pBase->m_nMaxNotchDimensionSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Notch_Chamfer")) == 0 && g_pBase->m_nMaxNotchChamferSaveCount != 0)
		{
			nMaxNotchChamferSaveCount++;
			if (nMaxNotchChamferSaveCount > g_pBase->m_nMaxNotchChamferSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Notch_Radius")) == 0 && g_pBase->m_nMaxNotchRadiusSaveCount != 0)
		{
			nMaxNotchRadiusSaveCount++;
			if (nMaxNotchRadiusSaveCount > g_pBase->m_nMaxNotchRadiusSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("User_Defect")) == 0 && g_pBase->m_nMaxUserDefectSaveCount != 0)
		{
			nMaxUserDefectSaveCount++;
			if (nMaxUserDefectSaveCount > g_pBase->m_nMaxUserDefectSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Mark")) == 0 && g_pBase->m_nMaxMarkSaveCount != 0)
		{
			nMaxMarkSaveCount++;
			if (nMaxMarkSaveCount > g_pBase->m_nMaxMarkSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("Exception")) == 0 && g_pBase->m_nMaxExceptionSaveCount != 0)
		{
			nMaxExceptionSaveCount++;
			if (nMaxExceptionSaveCount > g_pBase->m_nMaxExceptionSaveCount) continue;
		}
		else if (strDefectType.Compare(_T("License")) == 0 && g_pBase->m_nMaxLicenseSaveCount != 0)
		{
			nMaxLicenseSaveCount++;
			if (nMaxLicenseSaveCount > g_pBase->m_nMaxLicenseSaveCount) continue;
		}

		CString strSaveImagePath;
		strSaveImagePath.Format(_T("%s\\%s_%s_%s[%d].jpg"), strDefectFolder, g_pBase->m_strHPanelID, PANEL_SIDE[pDefect->m_DefectInfo.m_nSideIdx], strDefectType, pDefect->m_nIdx);

		CRect rectDefect;
		rectDefect.left = DEFECTIMAGE_WIDTH / 2 - pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width() / 2;
		rectDefect.right = DEFECTIMAGE_WIDTH / 2 + pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width() / 2;
		rectDefect.top = DEFECTIMAGE_HEIGHT / 2 - pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height() / 2;
		rectDefect.bottom = DEFECTIMAGE_HEIGHT / 2 + pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height() / 2;

		CheckDirectory(strSaveImagePath);

		int nMinSize_X = m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[(int)pDefect->m_DefectInfo.m_DefectLoc].m_nMinSize_Filter_X_um;
		int nMinSize_Y = m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[(int)pDefect->m_DefectInfo.m_DefectLoc].m_nMinSize_Filter_Y_um;
		nMinSize_X = nMinSize_X < 20 ? 20 : nMinSize_X;
		nMinSize_Y = nMinSize_Y < 20 ? 20 : nMinSize_Y;

		if (static_cast<int>(round(pDefect->m_dSizeX_um)) > nMinSize_X && static_cast<int>(round(pDefect->m_dSizeY_um)) > nMinSize_Y)
		{
			SaveDefectImage_with_Title(pDefect, CSize(DEFECTIMAGE_WIDTH, DEFECTIMAGE_HEIGHT), rectDefect, strSaveImagePath, cvScalar(0, 255, 0));
		}
	}

	g_pLog->DisplayMessage(_T("End of Save Defect Image OK.."));
}

int CPostProcess::GetInspectionDefect()
{
	if(m_pRecipe == NULL || m_pHardware == NULL)
		return 0;
				
	CHardwareSettings* pHard = m_pHardware;

	CCameraSettings* pCamera[MAX_CAMERA_COUNT][MAX_SCAN_COUNT] = {};

	for(int i=0; i<MAX_CAMERA_COUNT; i++)
		for(int j=0; j<MAX_SCAN_COUNT; j++)
			pCamera[i][j] = m_pHardware->GetCameraSettings(i, j);
	
	double dScanRes = 0.;
	double dConvRes = 0.;

	int nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;
	
	CDefect* pDefect = NULL;

	for(int iCam=0; iCam<pHard->GetCameraCount(); iCam++)	
	{
		int nCamDefectCount = m_pInspectCamera[iCam]->GetDefectCount();
		g_pLog->DisplayMessage(_T("[%d]Camera Defect Count : %d"), iCam, nCamDefectCount);

		for(int iDefect=0; iDefect < nCamDefectCount ; iDefect++)
		{
			pDefect = m_pInspectCamera[iCam]->GetDefect(iDefect);

			if(pDefect == NULL)
				continue;

			if(m_pGlassData->GetTotalDefectCount() >= MAX_DEFECT_COUNT_GLASS)
				continue;

			int nCamIdx = (pDefect->m_DefectInfo.m_nCamID < 0 || MAX_CAMERA_COUNT <= pDefect->m_DefectInfo.m_nCamID) ? 0 : pDefect->m_DefectInfo.m_nCamID;
			int nScanIdx = (pDefect->m_DefectInfo.m_nScanIdx < 0 || MAX_SCAN_COUNT <= pDefect->m_DefectInfo.m_nScanIdx) ? 0 : pDefect->m_DefectInfo.m_nScanIdx;

			if(pCamera[nCamIdx][nScanIdx] == NULL)	
				continue;		

			dScanRes = pCamera[nCamIdx][nScanIdx]->m_dScanResolution[nStageNo];
			dConvRes = pCamera[nCamIdx][nScanIdx]->m_dConvResolution[nStageNo];

			if (dScanRes <= 0.0 || dConvRes <= 0.0)	
				continue;

			if(DefectProcess(pDefect, m_pInspectCamera[iCam], pCamera[nCamIdx][nScanIdx]) == FALSE)
				continue;

			if(DefectProcess_Judge(pDefect) == FALSE)
				continue;

			CDefect* pNewDefect = new CDefect;
			*(pNewDefect) = *(pDefect);
			
			if(m_pGlassData->SetDefect(pNewDefect) == FALSE)
			{						
				delete pNewDefect;
				continue;
			}

			if(pNewDefect->m_bJudge_NG == TRUE)
			{
				CString strDefectType = g_strDefectType[pNewDefect->m_DefectInfo.m_DefectLoc];			
				CString strSaveImagePath;
				//strSaveImagePath.Format(_T("%s\\%03d_%s_%s_%s.jpg"),m_strDefectFolder,pNewDefect->m_nIdx, g_pBase->m_strHPanelID, PANEL_SIDE[pNewDefect->m_DefectInfo.m_nSideIdx], strDefectType);
				strSaveImagePath.Format(_T("%s\\%s_%s_%d.jpg"),m_strDefectFolder, g_pBase->m_strHPanelID, PANEL_SIDE[pNewDefect->m_DefectInfo.m_nSideIdx], pNewDefect->m_nIdx);

				CRect rectDefect;
				rectDefect.left		= DEFECTIMAGE_WIDTH/2	- pNewDefect->m_DefectInfo.m_rtDefectPos_pxl.Width()/2;
				rectDefect.right	= DEFECTIMAGE_WIDTH/2	+ pNewDefect->m_DefectInfo.m_rtDefectPos_pxl.Width()/2;
				rectDefect.top		= DEFECTIMAGE_HEIGHT/2	- pNewDefect->m_DefectInfo.m_rtDefectPos_pxl.Height()/2;
				rectDefect.bottom	= DEFECTIMAGE_HEIGHT/2	+ pNewDefect->m_DefectInfo.m_rtDefectPos_pxl.Height()/2;

				CheckDirectory(strSaveImagePath);
				// SaveDefectImage2(pNewDefect->m_Image,CSize(DEFECTIMAGE_WIDTH,DEFECTIMAGE_HEIGHT), rectDefect, strSaveImagePath);
				SaveDefectImage_with_Title(pNewDefect, CSize(DEFECTIMAGE_WIDTH,DEFECTIMAGE_HEIGHT), rectDefect, strSaveImagePath);

				pNewDefect->m_strSaveImagePath = strSaveImagePath;
			}
		}
	}
	
	return m_pGlassData->GetJudgeDefectCount();
}

BOOL CPostProcess::DefectProcess(CDefect* pDefect, CInspectCamera *pInspect, CCameraSettings* pCamera)
{
	CGlassRecipe* pRecipe = m_pRecipe;
	if(pRecipe == NULL)	
		return FALSE;	

	if(pCamera == NULL)	
		return FALSE;

	double	dScanRes = 0.,dConvRes = 0.;
	int		nMarginLeft;
	int		nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

	dScanRes = pCamera->m_dScanResolution[nStageNo];
	dConvRes = pCamera->m_dConvResolution[nStageNo];
	nMarginLeft = pCamera->m_nMarginLeft;	

	if (dScanRes <= 0.0 || dConvRes <= 0)	
		return FALSE;

	int nStartLine = m_pGlassData->GetSideData((DimensionDir) pDefect->m_DefectInfo.m_nSideIdx)->m_nGlassStartLine;
	
	/*
	pDefect->m_nUMOriginX = (int)((double) (pDefect->m_DefectInfo.m_ptDefectPos_pxl.y - nStartLine) * dScanRes);
	pDefect->m_nUMOriginY = (int)((double) (pDefect->m_DefectInfo.m_ptDefectPos_pxl.x * dConvRes));		// 荐沥 鞘夸..
	*/

	CSIDE_PARM* pSideParam = &pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx];

	if(DefectLoc_Chip <= pDefect->m_DefectInfo.m_DefectLoc && pDefect->m_DefectInfo.m_DefectLoc <= DefectLoc_In_Chamfer)
	{
		int nFirstAreaStart = nStartLine;
		int nSecondAreaStart = nStartLine + pSideParam->m_nCenterJudgeArea_StartLine_To_Start_pxl;
		int nThirdAreaStart = nStartLine + pSideParam->m_nCenterJudgeArea_StartLine_To_End_pxl;

		if(pDefect->m_DefectInfo.m_rtDefectPos_pxl.top < nSecondAreaStart)		pDefect->m_nJudgeArea = 0;
		else if(pDefect->m_DefectInfo.m_rtDefectPos_pxl.top < nThirdAreaStart)	pDefect->m_nJudgeArea = 1;
		else																	pDefect->m_nJudgeArea = 2;
	}

	int nJudgeArea = pDefect->m_nJudgeArea;

	pDefect->m_dSizeX_um	= (int)((double)pDefect->m_DefectInfo.m_rtDefectPos_pxl.Width() * dConvRes);
	pDefect->m_dSizeY_um	= (int)((double)pDefect->m_DefectInfo.m_rtDefectPos_pxl.Height() * dScanRes);

	switch(pDefect->m_DefectInfo.m_DefectLoc)
	{
	case DefectLoc_Chip:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Chip].m_nJudge_Size_Min_X_um[nJudgeArea];
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Chip].m_nJudge_Size_Min_Y_um[nJudgeArea];
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Chip].m_nJudge_Size_Min_OR_AND[nJudgeArea];
		break;
	case DefectLoc_Crack:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Crack].m_nJudge_Size_Min_X_um[nJudgeArea];
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Crack].m_nJudge_Size_Min_Y_um[nJudgeArea];
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Crack].m_nJudge_Size_Min_OR_AND[nJudgeArea];
		break;
	case DefectLoc_Burr:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Burr].m_nJudge_Size_Min_X_um[nJudgeArea];
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Burr].m_nJudge_Size_Min_Y_um[nJudgeArea];
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Burr].m_nJudge_Size_Min_OR_AND[nJudgeArea];
		break;
	case DefectLoc_Chamfer:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Chamfer].m_nJudge_Size_Min_X_um[nJudgeArea];
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Chamfer].m_nJudge_Size_Min_Y_um[nJudgeArea];
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_Chamfer].m_nJudge_Size_Min_OR_AND[nJudgeArea];
		break;
	case DefectLoc_In_Chip:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Chip].m_nJudge_Size_Min_X_um[nJudgeArea];
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Chip].m_nJudge_Size_Min_Y_um[nJudgeArea];
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Chip].m_nJudge_Size_Min_OR_AND[nJudgeArea];
		break;
	case DefectLoc_In_Crack:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Crack].m_nJudge_Size_Min_X_um[nJudgeArea];
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Crack].m_nJudge_Size_Min_Y_um[nJudgeArea];
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Crack].m_nJudge_Size_Min_OR_AND[nJudgeArea];
		break;
	case DefectLoc_In_Burr:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Burr].m_nJudge_Size_Min_X_um[nJudgeArea];
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Burr].m_nJudge_Size_Min_Y_um[nJudgeArea];
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Burr].m_nJudge_Size_Min_OR_AND[nJudgeArea];
		break;
	case DefectLoc_In_Chamfer:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Chamfer].m_nJudge_Size_Min_X_um[nJudgeArea];
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Chamfer].m_nJudge_Size_Min_Y_um[nJudgeArea];
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_InspectPrm[eSideInsType_In_Chamfer].m_nJudge_Size_Min_OR_AND[nJudgeArea];
		break;
	case DefectLoc_Top_Corner:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_nTopCorner_Judge_Size_Min_X_um;
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_nTopCorner_Judge_Size_Min_Y_um;
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_nTopCorner_Judge_Size_Min_OR_AND;
		break;
	case DefectLoc_Bot_Corner:
		pDefect->m_nJudge_X_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_nBottomCorner_Judge_Size_Min_X_um;
		pDefect->m_nJudge_Y_um	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_nBottomCorner_Judge_Size_Min_Y_um;
		pDefect->m_nJudge_Type	= m_pRecipe->m_SideParam[pDefect->m_DefectInfo.m_nSideIdx].m_nBottomCorner_Judge_Size_Min_OR_AND;
		break;
	default:
		break;
	}

	return TRUE;
}

void CPostProcess::CalcGlassSize()
{
	return;
	/*
	int					iCam,iScan;
	CHardwareSettings	*pHard = m_pHardware;
	CCameraSettings		*pCamera;	
	double				dGlasssizeY[2],dGlasssizeX[2];	
	double				dGlassSizeSumY[2],dGlassSizeCntY[2];		
	double				dDist;
	CAMERA_SCANDIR		ScanDirection;
	double				dScanRes;
	double				dConvRes;	
	int		nStageNo = g_pBase->m_nStageNo;

	if(nStageNo < 0 || nStageNo > 1)
		nStageNo = 0;

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

			ZeroMemory(dGlasssizeY,sizeof(double)*2);
			ZeroMemory(dGlasssizeX,sizeof(double)*2);

			CSide_Data* pSideData = m_pGlassData->GetSideData(pCamera->m_eDimension);

			dGlasssizeX[0] = pSideData->m_nGlassEdgeXPos[0];
			dGlasssizeX[1] = pSideData->m_nGlassEdgeXPos[1];
			dGlasssizeY[0] = pSideData->m_nGlassStartLine;
			dGlasssizeY[1] = pSideData->m_nGlassEndLine;

			dScanRes = pCamera->m_dScanResolution[nStageNo];
			dConvRes = pCamera->m_dConvResolution[nStageNo];

			dDist = sqrt(pow((dGlasssizeX[0]*dConvRes-dGlasssizeX[1]*dConvRes),2) + pow((dGlasssizeY[0]*dScanRes-dGlasssizeY[1]*dScanRes),2));
			if(dDist > 0)
			{
				ScanDirection = pCamera->m_eScanDir;
				dGlassSizeCntY[(int)ScanDirection]++;
				dGlassSizeSumY[(int)ScanDirection] += dDist;
			}
		}
	}

	// Glass Size
	for(int i=0;i<2;i++)
	{
		if(dGlassSizeCntY[i] > 0)
			m_pResultData->m_dGlassSize[i] = dGlassSizeSumY[i]/dGlassSizeCntY[i];
	}
	*/
}

void CPostProcess::MergeDefect()
{
	int			iCam,iDefect,iDefectDest;
	int			nDefectCount;
	CDefect		*pDefect,*pDefectDest;
	int			nMergeDistX,nMergeDistY;
	int			nRemoveCount = 0;
	CRect		rect,rectOrg,rectTgt;
	CHardwareSettings	*pHard = m_pHardware;
	CGlassRecipe		*pGlsRcp = m_pRecipe;		

	if(pGlsRcp == NULL)
		return;
	
	nMergeDistX = nMergeDistY = 5;

	for(iCam=0;iCam<pHard->GetCameraCount();iCam++)
	{
		nDefectCount = m_pInspectCamera[iCam]->GetDefectCount();

		for(iDefect=0;iDefect<nDefectCount-1;iDefect++)
		{
			pDefect = m_pInspectCamera[iCam]->GetDefect(iDefect);
			if(pDefect == NULL)
				continue;

			if(pDefect->m_bDefectMergeRemoved == TRUE)
				continue;

			//if(pDefect->m_DefectLoc == DefectLoc_Chamfer)
			//	continue;
			
			rectOrg = pDefect->m_DefectInfo.m_rtDefectPos_pxl;
			rectOrg.InflateRect(nMergeDistX,nMergeDistY);

			for(iDefectDest=iDefect+1;iDefectDest<nDefectCount;iDefectDest++)
			{
				pDefectDest = m_pInspectCamera[iCam]->GetDefect(iDefectDest);
				if(pDefectDest == NULL)
					continue;

				if(pDefectDest->m_DefectInfo.m_nScanIdx != pDefect->m_DefectInfo.m_nScanIdx)
					continue;

				if(pDefectDest->m_bDefectMergeRemoved == TRUE)
					continue;

				//if(pDefectDest->m_nCamDir != pDefect->m_nCamDir)
				//	continue;

				//if(pDefectDest->m_DefectLoc == DefectLoc_Chamfer)
				//	continue;

				if(pDefect->m_DefectInfo.m_DefectLoc != pDefectDest->m_DefectInfo.m_DefectLoc)
					continue;

				rectTgt = pDefectDest->m_DefectInfo.m_rtDefectPos_pxl;

				if(rect.IntersectRect(rectOrg,rectTgt) == TRUE)
				{
					pDefect->m_DefectInfo.m_rtDefectPos_pxl.left	= min(pDefect->m_DefectInfo.m_rtDefectPos_pxl.left, pDefectDest->m_DefectInfo.m_rtDefectPos_pxl.left);
					pDefect->m_DefectInfo.m_rtDefectPos_pxl.top		= min(pDefect->m_DefectInfo.m_rtDefectPos_pxl.top, pDefectDest->m_DefectInfo.m_rtDefectPos_pxl.top);
					pDefect->m_DefectInfo.m_rtDefectPos_pxl.right	= max(pDefect->m_DefectInfo.m_rtDefectPos_pxl.right, pDefectDest->m_DefectInfo.m_rtDefectPos_pxl.right);
					pDefect->m_DefectInfo.m_rtDefectPos_pxl.bottom	= max(pDefect->m_DefectInfo.m_rtDefectPos_pxl.bottom, pDefectDest->m_DefectInfo.m_rtDefectPos_pxl.bottom);
					pDefect->m_DefectInfo.m_ptDefectPos_pxl			= pDefect->m_DefectInfo.m_rtDefectPos_pxl.CenterPoint();
					pDefect->m_DefectInfo.m_nBlobCount				= pDefect->m_DefectInfo.m_nBlobCount + pDefectDest->m_DefectInfo.m_nBlobCount;
					pDefect->m_DefectInfo.m_nGray_Max				= max(pDefect->m_DefectInfo.m_nGray_Max, pDefectDest->m_DefectInfo.m_nGray_Max);
					pDefect->m_DefectInfo.m_nGray_Min				= min(pDefect->m_DefectInfo.m_nGray_Min, pDefectDest->m_DefectInfo.m_nGray_Min);
					pDefect->m_DefectInfo.m_nGray_Sum				= pDefect->m_DefectInfo.m_nGray_Sum + pDefectDest->m_DefectInfo.m_nGray_Sum;
					pDefect->m_DefectInfo.m_dGray_Avg				= (pDefect->m_DefectInfo.m_dGray_Avg + pDefectDest->m_DefectInfo.m_dGray_Avg)/2.0;

					pDefectDest->m_bDefectMergeRemoved = TRUE;
					nRemoveCount++;
				}				
			}
		}
	}

	g_pLog->DisplayMessage(_T("Defect Merge Count : %d"), nRemoveCount);	
}

BOOL CPostProcess::CreateDataDirectory()
{
	CheckDirectory(PATH_INSPECTION_DATA);
	m_strResultFolder.Format(_T("%s\\DATA_RESULT"),PATH_INSPECTION_DATA);
	CheckDirectory(m_strResultFolder);
	m_strDefectFolder.Format(_T("%s\\IMG_DEFECT\\%s\\%s"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID);
	DeleteFolder(m_strDefectFolder);
	CheckDirectory(m_strDefectFolder,TRUE);
	m_strSplineFolder.Format(_T("%s\\SPLINE\\%s\\%s"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID);
	CheckDirectory(m_strSplineFolder);
	m_strFullImgeFolder.Format(_T("%s\\IMG_FULL\\%s\\%s"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID);
	CheckDirectory(m_strFullImgeFolder);
	m_strImageMarkFolder.Format(_T("%s\\IMG_MARK\\%s\\%s"),PATH_INSPECTION_DATA,g_pBase->m_strLoadingDay,g_pBase->m_strHPanelID);
	CheckDirectory(m_strImageMarkFolder);
	
	return TRUE;
}

BOOL CPostProcess::DeleteFolder(const CString &strFolder)
{
	SHFILEOPSTRUCT FileOp = {0};
	TCHAR szTemp[MAX_PATH];

	wcscpy_s(szTemp, MAX_PATH, strFolder);
	szTemp[strFolder.GetLength() + 1] = NULL; // NULL巩磊啊 滴俺 甸绢啊具 茄促.

	FileOp.hwnd = NULL;
	FileOp.wFunc = FO_DELETE;
	FileOp.pFrom = NULL;
	FileOp.pTo = NULL;
	FileOp.fFlags = FOF_NOCONFIRMATION | FOF_NOERRORUI; // 犬牢皋矫瘤啊 救哆档废 汲沥
	FileOp.fAnyOperationsAborted = false;
	FileOp.hNameMappings = NULL;
	FileOp.lpszProgressTitle = NULL;
	FileOp.pFrom = szTemp;

	SHFileOperation(&FileOp);

	return true;
}

BOOL CPostProcess::CheckDirectory(const TCHAR szPathName[], BOOL bDelete)
{
	CFileFind finder;
	CString strTemp;
	CString strDir = szPathName;
	int nPos;

	BOOL bExist = finder.FindFile(szPathName);

	if(bDelete == TRUE)
	{
		DeleteFolder(szPathName);
		bExist = FALSE;
	}

	if (bExist == FALSE)
	{
		nPos = strDir.Find(_T("\\"));
		nPos = strDir.Find(_T("\\"), nPos+1);
		while(nPos > 0)
		{
			strTemp = strDir.Mid(0,nPos);
			if(0 < strTemp.GetLength())
			{
				if(CString("\\") == strTemp.GetAt(strTemp.GetLength()-1))
				{
					nPos = strDir.Find(_T("\\"), nPos+1);
					continue;
				}
			}
			if (finder.FindFile(strTemp) == FALSE)
			{
				if(::CreateDirectory(strTemp, NULL) == FALSE)
				{
					strTemp.Format(_T("[%s]Folder Create Fail. "), szPathName);

					//LogMessage(strTemp, 2);
					return FALSE;
				}
			}
			nPos = strDir.Find(_T("\\"), nPos+1);
		}
	}	
	return TRUE;
}

CString CPostProcess::GetResultPath(EM_RESULT_PATH ePath)
{
	CString			str;

	switch(ePath)
	{
	case EM_RESULT_FILE: str=m_strResultFolder; break;
	case EM_RESULT_DEFECT: str=m_strDefectFolder; break;
	case EM_RESULT_FULL: str=m_strFullImgeFolder; break;
	case EM_RESULT_MARK: str=m_strImageMarkFolder; break;
	}

	return str;
}

int CPostProcess::MeasrueCutLineResult(DimensionDir dir)
{
	if (m_pGlassData == NULL || m_pGlassData->GetGlassRecipe() == NULL)
		return 0;

	double dSun = 0;
	int nCount = m_pGlassData->GetGlassRecipe()->m_SideParam[dir].m_nSideDimensionCount;
	if (nCount > 0)
	{
		for (int i = 0; i < nCount; i++)
		{
			dSun += (m_pGlassData->GetSideData(dir)->m_dSideMeasrue_CutLine_Result_mm[i] + m_pGlassData->GetSideData(dir)->m_dSideMeasrue_CutLine_Offset_mm[i]);
		}
		return ((int)(dSun * 1000 / nCount));
	}
	return 0;
}