#include "StdAfx.h"
#include "CameraControlAlign.h"
#include "CHImageControls/CHImageProcess.h"
#include "MainFrm.h"
#include "CHReviewSetting/SystemInfo.h"
#include "CHReviewRecipe/RsRcpAlignInfo.h"

#define ALIGN_TEMPLATE_PATH _T("D:\\DIT_Review\\Recipe\\AlignImage\\")
//#define ALIGN_TEMPLATE_PATH _T("C:\\DIT_Review\\Recipe\\AlignImage\\") //210805

using namespace CHImageControls;

CCameraControlAlign::CCameraControlAlign(void)
{
	m_nLineType	= SystemLine_CPJT;
	m_nMachineType = SystemMachine_CPJT_QD, SystemMachine_CPJT_RGB, SystemMachine_CPJT_BANK, SystemMachine_CPJT_BDI, SystemMachine_CPJT_OC, SystemMachine_CPJT_CS;
	
	m_pACC2P = NULL;
	m_pVectorAlignLightControl = NULL;
	m_nViewMode = 0;
	m_strSaveImageBasePath = _T("");

	m_nAlignType = FALSE;

	InitializeCriticalSection(&m_csAlignFindProcess);
}

CCameraControlAlign::~CCameraControlAlign(void)
{
	DisconnectCamera();	

	DeleteCriticalSection(&m_csAlignFindProcess);
}

int	CCameraControlAlign::ConnectCamera(const VectorCameraControlInfo& vecCameraControlInfo)
{
	if (!CCameraController::ConnectCamera(vecCameraControlInfo))
	{
		return FALSE;	
	}

	int nConnectCameraCount = 0;

	for (VectorCameraControlIt it=m_vecCameraControl.begin(); it!=m_vecCameraControl.end(); it++)
	{
		CAutoLightControl *pControl = new CAutoLightControl((*it)->GetIndex());
		pControl->SetALC2P(static_cast<IAutoLightControl2Paraent*>(this));
		m_vecAutoLightControl.push_back(pControl);

		SLightData* pData = new SLightData();
		m_vecLightData.push_back(pData);

		// alloc finder
		CAlignFinder *pFinder = NULL;
// 		if (m_nLineType== SystemLine_FIC8 && m_nMachineType==SystemMachine_ITO && m_nAlignType)
// 		{
// 			int nIndex = (*it)->GetCameraIndex();
// 			pFinder = new CAlignFinder_Corner(nIndex);
// 			g_pLog->DisplayMessage(_T("[ConnectCamera] EdgeAlign Finder New Created!!"));
// 		}
// 		else
// 		{
			pFinder = new CAlignFinder((*it)->GetIndex());
			g_pLog->DisplayMessage(_T("[ConnectCamera] AlignMark Finder New Created : Index %d!!"), (*it)->GetIndex());
//		}

		// push back
		m_vecAlignFinder.push_back(pFinder);

		if(int(vecCameraControlInfo.size()) > nConnectCameraCount)
		{
			if(GetFrameRateApply()==1){

				if(SetFrameRate(nConnectCameraCount, vecCameraControlInfo[nConnectCameraCount].GetFrameCount()))
				{
					g_pLog->DisplayMessage(_T("[ConnectCamera] Align Camera Frame Rate Change Success!"));
				}
				else
				{
					g_pLog->DisplayMessage(_T("[ConnectCamera] Align Camera Frame Rate Change Fail!"));
				}

			}
		}		
		nConnectCameraCount++;
	}	

	return TRUE;
}

void CCameraControlAlign::SetAlignType(BOOL nAlignType)
{
	m_nAlignType = nAlignType;
}

//#3357 KYH Align Image 초기화 ADD START
void CCameraControlAlign::SetAlignClearImage()//210330 kyh Align 이미지 초기화
{
	//m_vecCameraImage[0]->GetImageData(View_Camera)->ClearImage(0); 
	//m_vecCameraImage[1]->GetImageData(View_Camera)->ClearImage(0); 
	for (int i = 0; i < (int)m_vecCameraImage.size(); i++)
	{
		/*m_vecCameraImage[i]->GetImageData(View_Camera).
		m_vecCameraImage[i]->GetImageData(View_Result)->ClearImage(0);
		m_vecCameraImage[i]->GetImageData(View_Matching)->ClearImage(0);*/
			m_vecCameraImage[i]->ClearImage(View_Result);
			m_vecCameraImage[i]->ClearImage(View_Camera);
			m_vecCameraImage[i]->ClearImage(View_Matching);
	}
}
//#3357 KYH Align Image 초기화 ADD END

void CCameraControlAlign::DisconnectCamera()
{
	CCameraController::DisconnectCamera();

	for (VectorAutoLightControlIt it=m_vecAutoLightControl.begin(); it!=m_vecAutoLightControl.end(); it++)
	{
		CAutoLightControl *pControl = static_cast<CAutoLightControl*>(*it);
		//delete pControl;
		pControl = NULL;
	}
	m_vecAutoLightControl.clear();

	for (VectorAlignFinderIt it=m_vecAlignFinder.begin(); it!=m_vecAlignFinder.end(); it++)
	{
		CAlignFinder *pFinder = static_cast<CAlignFinder*>(*it);
		delete pFinder;
		pFinder = NULL;
	}
	m_vecAlignFinder.clear();

	for (VectorLightDataIt it=m_vecLightData.begin(); it!=m_vecLightData.end(); it++)
	{
		SLightData *pData = static_cast<SLightData*>(*it);
		delete pData;
		pData = NULL;
	}
	m_vecLightData.clear();
}

int	CCameraControlAlign::Camera_Control(int nControlType)
{
	int nRetValue = 0;
	switch(nControlType)
	{
	case CameraControlStop:
		Camera_Stop();
		m_nControlType = nControlType;
		nRetValue = 1;
		break;

	case CameraControlLive:
		nRetValue = Camera_Live();
		break;

	case CameraControlStart:
		nRetValue = Camera_Start(1);
		break;
	}

	if (m_pACC2P)
	{
		m_pACC2P->IACC2P_CameraControl(m_nControlType);
	}

	return nRetValue;
}

int CCameraControlAlign::AlignProcess()
{
	int nViewIdx;
	for(VectorCameraControlIt it = m_vecCameraControl.begin(); it != m_vecCameraControl.end(); it++)
	{
		SAutoLightParam sControlParam;
		sControlParam.bAutoProcess = m_AlignRecipe.bAutoProcess;
		sControlParam.dTargetMin = m_AlignRecipe.dTargetMin;
		sControlParam.dTargetMax = m_AlignRecipe.dTargetMax;
		sControlParam.dLightLevelMin = m_AlignRecipe.dExposureMin;
		sControlParam.dLightLevelMax = m_AlignRecipe.dExposureMax;		

		nViewIdx = (*it)->GetIndex();
		if(m_vecAutoLightControl.size() <= nViewIdx) continue; //KMJ Added
		m_vecAutoLightControl[nViewIdx]->ProcessAutoLight(sControlParam);
	}

	return Align_Success;
}

// camera control 2 parent

BOOL CCameraControlAlign::ICC2P_GetCurrentFrame(int nCameraIndex, int nFrameWidth, int nFrameHeight, int nFrameChannels, CCHImageData* pImageData)
{
	if (m_pACC2P==NULL) return FALSE;

	return m_pACC2P->IACC2P_GetCurrentFrame(nCameraIndex, nFrameWidth, nFrameHeight, nFrameChannels, pImageData);
}

BOOL CCameraControlAlign::ICC2P_FrameCaptured(int nCameraIndex, int nFrameIndex, int nFrameCount)
{
	if (nCameraIndex<0 || nCameraIndex>=(int)m_vecCameraControl.size())
	{
		g_pLog->DisplayMessage(_T("camera index fail"));
		return FALSE;
	}

	EnterCriticalSection(&m_vecLightData[nCameraIndex]->csProcess);

	BYTE *pCameraBuffer = (BYTE*)m_vecCameraControl[nCameraIndex]->GetImageAddress(nFrameIndex);
	if (pCameraBuffer==NULL)
	{
		g_pLog->DisplayMessage(_T("frame index fail"));
		LeaveCriticalSection(&m_vecLightData[nCameraIndex]->csProcess);
		return FALSE;
	}

	double dTime = 0.0;
	m_vecCameraControl[nCameraIndex]->GetExposureTime(dTime);
	m_vecLightData[nCameraIndex]->dExposureTime = dTime;
	m_vecLightData[nCameraIndex]->dLightValue = CAutoLightControl::GetAverageValue((BYTE*)pCameraBuffer, 
		m_vecCameraControl[nCameraIndex]->GetWidth(), 
		m_vecCameraControl[nCameraIndex]->GetHeight(), 
		m_vecCameraControl[nCameraIndex]->GetWidthStep());

	if (m_pACC2P)
	{
		int nLightLevel = 0;
		if (m_pACC2P->IACC2P_GetLightLevel(nCameraIndex, nLightLevel))
		{
			m_vecLightData[nCameraIndex]->nControlLightLevel = nLightLevel;
		}
	}

	LeaveCriticalSection(&m_vecLightData[nCameraIndex]->csProcess);

	m_vecCameraImageIndex[nCameraIndex] = View_Camera;
	BYTE *pImageBuffer = (BYTE*)((m_vecCameraImage[nCameraIndex])->GetImageData(View_Camera))->GetImageBuffer();
	if (pImageBuffer==NULL)
	{
		g_pLog->DisplayMessage(_T("buffer index fail"));
		return FALSE;
	}

	memcpy(pImageBuffer, pCameraBuffer, sizeof(BYTE)*m_vecCameraImageSize[nCameraIndex]);
//	m_vecCameraControl[nCameraIndex]->ReleaseImageAddress(pCameraBuffer);

	if (m_pACC2P==NULL) 
	{
		g_pLog->DisplayMessage(_T("accp is null!"));
		return FALSE;
	}

	// 	if (m_nProcessStatus==PCControl_ReviewStart)
	// 	{
	// 		g_pLog->DisplayMessage(_T("AlignProcess() 진입 %d %d"), nCameraIndex, nFrameIndex);
	// 		m_nProcessStatus = PCControl_ReviewEnd;
	// 		AlignProcess();
	// 		g_pLog->DisplayMessage(_T("AlignProcess() 종료 %d %d"), nCameraIndex, nFrameIndex);
	// 	}
	m_pACC2P->IACC2P_FrameCaptured(nCameraIndex, m_nViewMode, (m_vecCameraImage[nCameraIndex])->GetImageData(m_nViewMode));
	return TRUE;
}

BOOL CCameraControlAlign::LoadTemplateImage()
{
	BOOL bAllLoad = TRUE;

	CString strFilename = _T("");
	CCHImageData tempImage;
	/*< LYW 20211012 - #3671 ADD Start >*/
	CCHImageData assistanttempImage;
	/*< LYW 20211012 - #3671 ADD End >*/
	for (int i=0; i<2; i++)
	{
		if(m_vecCameraImage.size() <= i) continue;
		(m_vecCameraImage[i]->GetImageData(View_Template))->ReleaseImage();
		/*< LYW 20211012 - #3671 ADD Start >*/
		(m_vecCameraImage[i]->GetImageData(View_AssistantTemplate))->ReleaseImage();
		/*< LYW 20211012 - #3671 ADD End >*/

		// load
		CString strFilename = ALIGN_IMAGE_PATH;
		/*< LYW 20211012 - #3671 ADD Start >*/
		CString strAssistantFilename = ALIGN_IMAGE_PATH;
		/*< LYW 20211012 - #3671 ADD End >*/

		if (i==0)
		{
			strFilename += _T("\\") + m_AlignRecipe.strFirstImageFile;
			/*< LYW 20211012 - #3671 ADD Start >*/
			strAssistantFilename += _T("\\") + m_AlignRecipe.strFirstAssistantImageFile;
			/*< LYW 20211012 - #3671 ADD End >*/

		}
		else if (i==1)
		{
			strFilename += _T("\\") + m_AlignRecipe.strSecondImageFile;
			/*< LYW 20211012 - #3671 ADD Start >*/
			strAssistantFilename += _T("\\") + m_AlignRecipe.strSecondAssistantImageFile;
			/*< LYW 20211012 - #3671 ADD End >*/
		}

		//strFilename += m_AlignRecipe.strTemplateName[i];

		if (tempImage.LoadImage(strFilename)==FALSE)
		{
			bAllLoad = bAllLoad && FALSE;
			continue;
		}

		/*< LYW 20211012 - #3671 ADD Start >*/
		if (assistanttempImage.LoadImage(strAssistantFilename) == FALSE)
		{
			bAllLoad = bAllLoad && FALSE;
			continue;
		}
		/*< LYW 20211012 - #3671 ADD End >*/

		bAllLoad = bAllLoad && tempImage.GetBandImage(BandTypeGray, m_vecCameraImage[i]->GetImageData(View_Template));
		/*< LYW 20211012 - #3671 ADD Start >*/
		bAllLoad = bAllLoad && assistanttempImage.GetBandImage(BandTypeGray, m_vecCameraImage[i]->GetImageData(View_AssistantTemplate));
		/*< LYW 20211012 - #3671 ADD End >*/
	}

	return bAllLoad;
}

BOOL CCameraControlAlign::ChangeExposureTime()
{
	if (!m_AlignRecipe.bManualProcess) 
	{
		BOOL bAllLoad = TRUE;
		bAllLoad = m_vecCameraControl[0]->SetExposureAuto(TRUE);
		bAllLoad = m_vecCameraControl[1]->SetExposureAuto(TRUE);
		
		g_pLog->DisplayMessage(_T("CCameraControlAlign::AlignCam1 Exposure is AUTO!"));
		g_pLog->DisplayMessage(_T("CCameraControlAlign::AlignCam2 Exposure is AUTO!"));

		return TRUE;
	}

	BOOL bAllLoad = TRUE;
	bAllLoad = m_vecCameraControl[0]->SetExposureTime(m_AlignRecipe.dFirstCamExposure);
	bAllLoad = m_vecCameraControl[1]->SetExposureTime(m_AlignRecipe.dSecondCamExposure);

	g_pLog->DisplayMessage(_T("CCameraControlAlign::AlignCam1 Exposure is %.1lfms!"), m_AlignRecipe.dFirstCamExposure);
	g_pLog->DisplayMessage(_T("CCameraControlAlign::AlignCam2 Exposure is %.1lfms!"), m_AlignRecipe.dSecondCamExposure);

	return bAllLoad;
}

BOOL CCameraControlAlign::ChangeLightLevel()
{
	if (m_pACC2P)
	{
		m_pACC2P->IACC2P_SetLightLevel(0, (int)m_AlignRecipe.dFirstCamExposure);
		m_pACC2P->IACC2P_SetLightLevel(1, (int)m_AlignRecipe.dSecondCamExposure);
		g_pLog->DisplayMessage(_T("CCameraControlAlign::AlignCam1 Light Level is %d"), (int)m_AlignRecipe.dFirstCamExposure);
		g_pLog->DisplayMessage(_T("CCameraControlAlign::AlignCam2 Light Level is %d"), (int)m_AlignRecipe.dSecondCamExposure);
		return TRUE;
	}

	// 1029
	if(m_pVectorAlignLightControl)
	{
		if((int)m_pVectorAlignLightControl->size() == 2)
		{
			(*m_pVectorAlignLightControl)[0]->SetLightLevel((int)m_AlignRecipe.dFirstCamExposure);
			(*m_pVectorAlignLightControl)[1]->SetLightLevel((int)m_AlignRecipe.dSecondCamExposure);

			g_pLog->DisplayMessage(_T("CCameraControlAlign::AlignCam1 Light Level is %d"), (int)m_AlignRecipe.dFirstCamExposure);
			g_pLog->DisplayMessage(_T("CCameraControlAlign::AlignCam2 Light Level is %d"), (int)m_AlignRecipe.dSecondCamExposure);

			return TRUE;
		}
	}

	return FALSE;
}

void CCameraControlAlign::UpdateProcessStatus(int nLineType, int nMachineType, int nProcessStatus, const CGlassResult* pGlassResult)
{
	if (pGlassResult==NULL) return;

	m_nProcessStatus = nProcessStatus;

	switch(m_nProcessStatus)
	{
	case ProcessLoading:
		m_AlignRecipe = pGlassResult->m_AlignRecipe;
		m_AlignResult.Reset();
		if (LoadTemplateImage())
		{
			g_pLog->DisplayMessage(_T("[CameraControlAlign] Load Template is Success!"));
		}
		break;
	}

}

BOOL CCameraControlAlign::SetTemplateImage(int nCameraIndex, CCHImageData* pImageData)
{
	if (pImageData==NULL || nCameraIndex<0 || nCameraIndex>=(int)m_vecCameraImage.size())
	{
		return FALSE;
	}

	return pImageData->CopyImageTo(m_vecCameraImage[nCameraIndex]->GetImageData(View_Template));
}

BOOL CCameraControlAlign::GetTemplateImage(int nCameraIndex, CCHImageData* pImageData)
{
	if (pImageData==NULL || nCameraIndex<0 || nCameraIndex>=(int)m_vecCameraImage.size())
	{
		return FALSE;
	}

	return pImageData->CopyImageFrom(m_vecCameraImage[nCameraIndex]->GetImageData(View_Template));
}

BOOL CCameraControlAlign::GetResultImage(int nCameraIndex, CCHImageData* pImageData)
{
	if (pImageData==NULL || nCameraIndex<0 || nCameraIndex>=(int)m_vecCameraImage.size())
	{
		return FALSE;
	}

	return pImageData->CopyImageFrom(m_vecCameraImage[nCameraIndex]->GetImageData(View_Result));
}


BOOL CCameraControlAlign::SaveResultImage(int nCameraIndex, const CString& strFilename)
{
	if (nCameraIndex<0 || nCameraIndex>=(int)m_vecCameraImage.size())
	{
		return FALSE;
	}

	return (m_vecCameraImage[nCameraIndex]->GetImageData(View_Result))->SaveImage(strFilename);
}

void CCameraControlAlign::SetSaveImageBasePath(CString strPath)
{
	m_strSaveImageBasePath = strPath;
}

CCameraControl* CCameraControlAlign::GetCameraControl(int nCameraIndex)
{
	for (VectorCameraControlIt it=m_vecCameraControl.begin(); it!=m_vecCameraControl.end(); it++)
	{
		if ((*it)->GetIndex()==nCameraIndex)
		{
			return (*it);
		}
	}
	return NULL;
}

BOOL CCameraControlAlign::AL2P_ChangeExposure(int nCameraIndex, double dExposureTime)
{
	CCameraControl *pCamera = GetCameraControl(nCameraIndex);
	if (pCamera==NULL) return FALSE;

	return pCamera->SetExposureTime(dExposureTime);
}

BOOL CCameraControlAlign::AL2P_ChangeLightLevel(int nCameraIndex, int nLightLevel)
{
	if (m_pACC2P)
	{
		return m_pACC2P->IACC2P_SetLightLevel(nCameraIndex, nLightLevel);
	}

	// 1029
	if(m_pVectorAlignLightControl)
	{
		if(nCameraIndex >= 0 && nCameraIndex < (int)m_pVectorAlignLightControl->size())
		{
			(*m_pVectorAlignLightControl)[nCameraIndex]->SetLightLevel(nLightLevel);
			return TRUE;
		}
	}

	return FALSE;
}

BOOL CCameraControlAlign::AL2P_ChangeGain(int nCameraIndex, double dGainValue)
{
	return FALSE;
}

BOOL CCameraControlAlign::AL2P_GetCurrentLightExposure(int nCameraIndex, double& dLight, double& dExposure)
{

	EnterCriticalSection(&m_vecLightData[nCameraIndex]->csProcess);
	
	dLight = m_vecLightData[nCameraIndex]->dLightValue;
	dExposure = m_vecLightData[nCameraIndex]->dExposureTime;

	LeaveCriticalSection(&m_vecLightData[nCameraIndex]->csProcess);

	return TRUE;
}

BOOL CCameraControlAlign::AL2P_GetCurrentLightLevel(int nCameraIndex, double& dLight, int& nLightLevel)
{

	EnterCriticalSection(&m_vecLightData[nCameraIndex]->csProcess);

	dLight = m_vecLightData[nCameraIndex]->dLightValue;
	nLightLevel = m_vecLightData[nCameraIndex]->nControlLightLevel;

	LeaveCriticalSection(&m_vecLightData[nCameraIndex]->csProcess);

	return TRUE;
}

void CCameraControlAlign::AL2P_ProcessEnd(int nCameraIndex, int nResultCode, double dLightValue, double dExposureTime)
{
	BOOL bRet = FALSE;
	// auto light result
	m_AlignResult.nAutoLightResult[nCameraIndex] = nResultCode;
	m_AlignResult.dExposureTime[nCameraIndex] = dExposureTime;

	// find align mark
	bRet = FindAlignMark(nCameraIndex);
	
	// send find result
	EnterCriticalSection(&m_csAlignFindProcess);
	
	if (m_pACC2P && m_AlignResult.AlignFindEnd())	
	{
		// 얼라인 찾기
		m_AlignResult.nResultCode = m_AlignResult.GetResultCode();
		m_AlignResult.SetFindResult(m_AlignRecipe);

		// 부모로 결과 전송
		m_pACC2P->IACC2P_AlignResult(m_AlignResult);

		m_AlignResult.Reset();
	}

	LeaveCriticalSection(&m_csAlignFindProcess);
}

void CCameraControlAlign::AL2P_ProcessEnd(int nCameraIndex, int nResultCode, double dLightValue, int nLightLevel)
{
	BOOL bRet = FALSE;
	// auto light result
	m_AlignResult.nAutoLightResult[nCameraIndex] = nResultCode;
	m_AlignResult.nControlLightLevel[nCameraIndex] = nLightLevel;

	// find align mark
	bRet = FindAlignMark(nCameraIndex);

	// send find result
	EnterCriticalSection(&m_csAlignFindProcess);

	if (m_pACC2P && m_AlignResult.AlignFindEnd())	
	{
		// 얼라인 찾기
		m_AlignResult.nResultCode = m_AlignResult.GetResultCode();
		m_AlignResult.SetFindResult(m_AlignRecipe);

		// 부모로 결과 전송
		m_pACC2P->IACC2P_AlignResult(m_AlignResult);

		m_AlignResult.Reset();
	}

	LeaveCriticalSection(&m_csAlignFindProcess);
}

void CCameraControlAlign::AL2P_CurrentResult(int nCameraIndex, int nCount, int nResultCode, double dLightValue, double dExposureTime)
{
	g_pLog->DisplayMessage(_T("AL Current [%d] Align Camera, Iter: %d, Code: %d, Light: %.3lf, Exposure: %.3lf"), nCameraIndex, nCount, nResultCode, dLightValue, dExposureTime);
}

void CCameraControlAlign::AL2P_CurrentResult(int nCameraIndex, int nCount, int nResultCode, double dLightValue, int nLightLevel)
{
	g_pLog->DisplayMessage(_T("AL Current [%d] Align Camera, Iter: %d, Code: %d, Light: %.3lf, Control Light Level: %d"), nCameraIndex, nCount, nResultCode, dLightValue, nLightLevel);
}

BOOL CCameraControlAlign::FindAlignMark(int nCameraIdx)
{
	if(nCameraIdx < 0 || nCameraIdx >= m_vecCameraImage.size()) return FALSE;
	
	CCameraImageData* pCameraImage = m_vecCameraImage[nCameraIdx];
	CAlignFinder* pAlignFinder = m_vecAlignFinder[nCameraIdx];

	/*< LYW 20211014 - #index MOD Start >*/
	if (pCameraImage == NULL || pAlignFinder == NULL || m_pACC2P == NULL) return FALSE;
	/*< LYW 20211014 - #index MOD End >*/
	/*< Origin Code >*/
	//if (pCameraImage == NULL || pAlignFinder == NULL) return FALSE;

	// set find param;
	SAlignFindParam findParam;
	findParam.bMatchProcess			= m_AlignRecipe.bUseImage;
	findParam.dMatchRate			= m_AlignRecipe.dMatchingRate;

	findParam.bEdgeProcess			= m_AlignRecipe.bUseEdge;
	findParam.nAlignWidth			= m_AlignRecipe.nEdgeWidth;
	findParam.nAlignHeight			= m_AlignRecipe.nEdgeHeight;
	findParam.nEdgeThreshold		= m_AlignRecipe.nEdgeThreshold;
	findParam.nMergeRange			= m_AlignRecipe.nMergeRange;
	findParam.dEdgeRate				= m_AlignRecipe.dEdgeRate;
	findParam.dMatchingPixelStandard = _tcstod(m_AlignRecipe.strMatchingPixelStandard,NULL);
	findParam.dMatchingAlarmCondition = _tcstod(m_AlignRecipe.strMatchingAlarmCondition, NULL);
//	findParam.m_nAlignMarkPos		= m_AlignRecipe.nAlignMarkPosition;


	CString strPath = _T("");
	CTime time = CTime::GetCurrentTime();
	strPath.Format(_T("%s\\Cam%02d_AlignORG_%04d%02d%02d%02d%02d%02d.BMP"), m_strSaveImageBasePath, nCameraIdx, 
		time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());
	(pCameraImage->GetImageData(View_Camera))->SaveImage(strPath);

	CString uploadAlignimage = _T("");
	uploadAlignimage.Format(_T("Cam%02d_AlignORG_%04d%02d%02d%02d%02d%02d.BMP"), nCameraIdx, 
		time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());

	//공유메모리 얼라인 이미지명 업로드 chm 190623
	/*if(nCameraIdx == 0){
		size_t CharactersConverted;
		wcstombs_s(&CharactersConverted,CDitGlassRawClient::GetInstance()->GetGlassData()->m_strAlignMarkFisrt, uploadAlignimage, _TRUNCATE);
	}
	else{
		size_t CharactersConverted;
		wcstombs_s(&CharactersConverted,CDitGlassRawClient::GetInstance()->GetGlassData()->m_strAlignMarkSecond, uploadAlignimage, _TRUNCATE);
	}*/
	// find process
	CCHImageData camImage;

	//#3671 TEST CODE Start
// 	CCHImageData TestImage;
// 
// 	(m_vecCameraImage[nCameraIdx]->GetImageData(View_Camera))->ReleaseImage();
// 	CString strFilename = ALIGN_IMAGE_PATH;
// 	if (nCameraIdx == 0)
// 	{
// 		strFilename += _T("\\Test1.BMP");
// 	}
// 	else
// 	{
// 		strFilename += _T("\\Test2.BMP");
// 	}
// 	TestImage.LoadImage(strFilename);
// 	TestImage.GetBandImage(BandTypeGray, m_vecCameraImage[nCameraIdx]->GetImageData(View_Camera));
// 	(m_vecCameraImage[nCameraIdx]->GetImageData(View_Camera))->GetBandImage(BandTypeGray, &camImage);
	//#3671 TEST CODE End
// find process	 바슬러 카메라가 3채널짜리라서 시퀀스 돌때는 1채널로 바꿔서 돔 ksm
	if ((pCameraImage->GetImageData(View_Camera))->GetChannels() > 1)
		(pCameraImage->GetImageData(View_Camera))->GetBandImage(BandTypeGray, &camImage);
	else
		(pCameraImage->GetImageData(View_Camera))->CopyImageTo(&camImage);

	
	//SAlignFindResult findResult = pAlignFinder->FindAlign(pCameraImage->GetImageData(View_Matching), findParam, pCameraImage->GetImageData(View_Template));
	SAlignFindResult findResult = pAlignFinder->FindAlign(&camImage, findParam, pCameraImage->GetImageData(View_Template));
	g_pLog->DisplayMessage(_T("Main TempleteMatching Result : %d Cam ResultCode = %d, PixelX = %d, PixelY = %d, MatchingRate = %.3lf"), nCameraIdx, findResult.nResultCode, int(findResult.dPosX + 0.5), int(findResult.dPosY + 0.5), findResult.dMatchValue);

	// result process
	if (findResult.nResultCode==AlignMatch_Success)
	{
		g_pLog->DisplayMessage(_T("Main TempleteMatching Success!"));
		m_AlignResult.nFindAlign[nCameraIdx] = 1;
		m_AlignResult.dFindPixelX[nCameraIdx] = int(findResult.dPosX + 0.5);
		m_AlignResult.dFindPixelY[nCameraIdx] = int(findResult.dPosY + 0.5);
		m_AlignResult.dFindScore[nCameraIdx] = findResult.dMatchValue;
	}
	/*< LYW 20211013 - #3671 ADD Start >*/

	else
	{
		SAlignFindResult findAssistantResult = pAlignFinder->FindAlign(&camImage, findParam, pCameraImage->GetImageData(View_AssistantTemplate));
		g_pLog->DisplayMessage(_T("Assistant TempleteMatching Result : %d Cam ResultCode = %d, PixelX = %d, PixelY = %d, MatchingRate = %.3lf"), nCameraIdx, findAssistantResult.nResultCode, int(findAssistantResult.dPosX + 0.5), int(findAssistantResult.dPosY + 0.5), findAssistantResult.dMatchValue);
		if (findAssistantResult.nResultCode == AlignMatch_Success)
		{
			g_pLog->DisplayMessage(_T("Assistant TempleteMatching Success!"));
			m_AlignResult.nFindAlign[nCameraIdx] = 1;
			m_AlignResult.dFindPixelX[nCameraIdx] = int(findAssistantResult.dPosX + 0.5);
			m_AlignResult.dFindPixelY[nCameraIdx] = int(findAssistantResult.dPosY + 0.5);
			m_AlignResult.dFindScore[nCameraIdx] = findAssistantResult.dMatchValue;
		}

		else 
		{
			int dffmain2assistanstX = int(findResult.dPosX) - int(findAssistantResult.dPosX);
			int dffmain2assistanstY = int(findResult.dPosY) - int(findAssistantResult.dPosY);
			g_pLog->DisplayMessage(_T("Main, Assistant TempleteMatching All Low Score! differenceX = %d, differenceY = %d"), dffmain2assistanstX, dffmain2assistanstY);

			if (abs(dffmain2assistanstX) <= findParam.dMatchingPixelStandard && abs(dffmain2assistanstY) <= findParam.dMatchingPixelStandard && findResult.dMatchValue != 0.0)
			{
				m_AlignResult.nFindAlign[nCameraIdx] = 1;
				m_AlignResult.dFindPixelX[nCameraIdx] = int(findResult.dPosX + 0.5);
				m_AlignResult.dFindPixelY[nCameraIdx] = int(findResult.dPosY + 0.5);
				m_AlignResult.dFindScore[nCameraIdx] = findResult.dMatchValue;
				m_pACC2P->IACC2P_SetAccumaulate(m_pACC2P->IACC2P_GetAccumaulate() + 1);
				g_pLog->DisplayMessage(_T("Main, Assistant Templete Find Same Point! Align Success! Accumaulate = %d"), m_pACC2P->IACC2P_GetAccumaulate());
			}

			else
			{
				g_pLog->DisplayMessage(_T("Main Assistant Templete Don`t Find Same Point! Align Fail!"));
				m_AlignResult.nFindAlign[nCameraIdx] = 0;
				m_AlignResult.dFindScore[nCameraIdx] = findResult.dMatchValue;
			}

			if (m_pACC2P->IACC2P_GetAccumaulate() > findParam.dMatchingAlarmCondition)
			{
				m_AlignResult.nFindAlign[nCameraIdx] = 0;
				m_AlignResult.dFindScore[nCameraIdx] = findResult.dMatchValue;
				m_pACC2P->IACC2P_SetAccumaulate(0);
				g_pLog->DisplayMessage(_T("Low Matching, But Align Same Point, Count is more Than MatchingAlarmCondition , Accumaulate = %d Reset"), m_pACC2P->IACC2P_GetAccumaulate());
			}
		}
	}
	/*< LYW 20211013 - #3671 ADD End >*/

	/*< LYW 20211013 - #3671 Delete Start >*/
// 	else
// 	{
// 		m_AlignResult.nFindAlign[nCameraIdx] = 0;
// 		m_AlignResult.dFindScore[nCameraIdx] = findResult.dMatchValue;
// 	}
	/*< LYW 20211013 - #3671 Delete End >*/
	
	// save threshold image
	strPath.Format(_T("%s\\Cam%02d_AlignTH_%04d%02d%02d%02d%02d%02d.jpg"), m_strSaveImageBasePath, nCameraIdx, 
		time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());
	pAlignFinder->SaveThresholdImage(strPath);

	// save Result Image 20210208 얼라인 결과 저장
	strPath.Format(_T("%s\\Cam%02d_AlignResult_%04d%02d%02d%02d%02d%02d.jpg"), m_strSaveImageBasePath, nCameraIdx,
		time.GetYear(), time.GetMonth(), time.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());
	pAlignFinder->SaveResultImage(strPath);

	Sleep(10);
	if (nCameraIdx == 0)
	{
		m_AlignResult.strAlignFirest = strPath;
	}
	else
	{
		m_AlignResult.strAlignSecond = strPath;
	}


	// update matching image
	pAlignFinder->GetBlobImage(pCameraImage->GetImageData(View_Matching));
	
	// update result image
 	pAlignFinder->GetResultImage(pCameraImage->GetImageData(View_Result));

	return TRUE;
}


CAlignResult CCameraControlAlign::FindAlignMark(const VectorString& vectorFilename)
{
	m_AlignResult.Reset();

	// template image
	CCHImageData orgImage;
	BOOL bAllSuccess = TRUE;
	for (int i=0; i<(int)m_vecCameraImage.size(); i++)
	{
		(m_vecCameraImage[i]->GetImageData(View_Template))->ReleaseImage();
		
		CString strFilename = ALIGN_TEMPLATE_PATH;
		strFilename += vectorFilename[i];

		// load template
		if (orgImage.LoadImage(strFilename)) 
		{
			orgImage.GetBandImage(BandTypeGray, m_vecCameraImage[i]->GetImageData(View_Template));
		}

		// find align mark
		bAllSuccess = bAllSuccess && FindAlignMark(i);
	}

	m_AlignResult.nResultCode = m_AlignResult.GetResultCode();

// 	if (bAllSuccess==FALSE) 
// 	{
// 		m_AlignResult.nResultCode = Align_Fail;
// 	}

	return m_AlignResult;
}

void CCameraControlAlign::IALC2P_DisplayMessage( int nIndex, const TCHAR* lpstrFormat, ... )
{

}

BOOL CCameraControlAlign::IALC2P_ChangeLightLevel( int nIndex, double dLightLevel )
{
	if (m_pACC2P)
	{
		return m_pACC2P->IACC2P_SetLightLevel(nIndex, (int)dLightLevel);
	}

	// 1029
	if(m_pVectorAlignLightControl)
	{
		if(nIndex >= 0 && nIndex < (int)m_pVectorAlignLightControl->size())
		{
			(*m_pVectorAlignLightControl)[nIndex]->SetLightLevel(dLightLevel);
			return TRUE;
		}
	}

	return FALSE;
}

BOOL CCameraControlAlign::IALC2P_GetCurrentLightLevel( int nIndex, double& dLight, double& dLightLevel )
{
	EnterCriticalSection(&m_vecLightData[nIndex]->csProcess);

	dLight = m_vecLightData[nIndex]->dLightValue;
	dLightLevel = m_vecLightData[nIndex]->nControlLightLevel;

	LeaveCriticalSection(&m_vecLightData[nIndex]->csProcess);

	return TRUE;
}

void CCameraControlAlign::IALC2P_ProcessEnd( int nIndex, int nResultCode, double dLightValue, double dLightLevel )
{
	BOOL bRet = FALSE;
	// auto light result
	m_AlignResult.nAutoLightResult[nIndex] = nResultCode;
	m_AlignResult.nControlLightLevel[nIndex] = (int)dLightLevel;

	// find align mark
	bRet = FindAlignMark(nIndex);

	// send find result
	EnterCriticalSection(&m_csAlignFindProcess);

	if (m_pACC2P && m_AlignResult.AlignFindEnd())	
	{
		// 얼라인 찾기
		m_AlignResult.nResultCode = m_AlignResult.GetResultCode();
		m_AlignResult.SetFindResult(m_AlignRecipe);

		// 부모로 결과 전송
		m_pACC2P->IACC2P_AlignResult(m_AlignResult);

		m_AlignResult.Reset();
	}

	LeaveCriticalSection(&m_csAlignFindProcess);
}

void CCameraControlAlign::IALC2P_CurrentResult( int nIndex, int nCount, int nResultCode, double dLightValue, double dLightLevel )
{
	g_pLog->DisplayMessage(_T("AL Current [%d] Align Camera, Iter: %d, Code: %d, Light: %.3lf, Control Light Level: %d"), nIndex, nCount, nResultCode, dLightValue, (int)dLightLevel);
}

BOOL CCameraControlAlign::SaveAutoTempImage( int nFirstAlignX, int nFristAlignY, int nSecondAlignX, int nSecondAlignY )
{
	if(int(m_vecCameraImage.size()) < 2) return FALSE;

	for(int nCnt=0; nCnt < int(m_vecCameraImage.size()); nCnt++)
	{
		CCameraImageData* pCameraImage = m_vecCameraImage[nCnt];
		if(pCameraImage == NULL)	continue;

		CCHImageData* pImageData = NULL;
		pImageData = pCameraImage->GetImageData(View_Camera);
		if(pImageData == NULL || pImageData->GetWidth() < 1 || pImageData->GetHeight() < 1)	continue;

		CString szFilter = _T("BMP(*.bmp)|*.bmp| JPG(*.jpg)|*.jpg| All Files(*.*)|*.*||");

		CString strPath;
		CFileDialog dlg(FALSE, NULL, NULL, OFN_HIDEREADONLY, szFilter);
		dlg.m_ofn.lpstrTitle = _T("Save Templete Image");

		if(dlg.DoModal() == IDCANCEL) return FALSE;

		int nAlignMarkSizeX = m_AlignRecipe.nEdgeWidth;
		int nAlignMarkSizeY = m_AlignRecipe.nEdgeHeight;

		CRect rtRect;

		if(nCnt ==0)
		{
			rtRect.left = nFirstAlignX - nAlignMarkSizeX/2;
			rtRect.top = nFristAlignY - nAlignMarkSizeY/2;
		}
		else
		{
			rtRect.left = nSecondAlignX - nAlignMarkSizeX/2;
			rtRect.top = nSecondAlignY - nAlignMarkSizeY/2;
		}

		CString strFileName;
		strFileName.Format(_T("%s.bmp"), dlg.GetPathName());

		CCHImageData subImage;

		pImageData->GetSubImage(rtRect.left, rtRect.top, nAlignMarkSizeX, nAlignMarkSizeY, &subImage);

		if (subImage.SaveImage(strFileName)==FALSE) return FALSE;
	}

	return TRUE;
}

BOOL CCameraControlAlign::SetFrameRate(int nIndex,  double dRate )
{
	int nCameraCount = int(m_vecCameraControl.size());
	if(nCameraCount < 1)	return FALSE;

	if(int(m_vecCameraControl.size()) <= nIndex)	return FALSE;
	
	return m_vecCameraControl[nIndex]->SetFrameRate(dRate);
}

BOOL CCameraControlAlign::AlignCameraDisconnectCheck()
{
	if(int(m_vecCameraControl.size()) < 1) return FALSE;

	int nCamCnt = 0;
	for (VectorCameraControlIt it=m_vecCameraControl.begin(); it!=m_vecCameraControl.end(); it++)
	{
		if(m_vecCameraControl[nCamCnt]->DisconnectCheck() == FALSE) return FALSE;

		nCamCnt++;
	}

	return TRUE;
}