// Glass.cpp: implementation of the CGlass class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Glass_Data.h"
#include <math.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CGlass_Data::CGlass_Data(void)
{	
	m_pGlassRecipe = NULL;
	m_pHardwareSetting = NULL;
	m_nStageNo = 0;
	m_bSimulation = FALSE;

	ResetGlass();
}

CGlass_Data::~CGlass_Data()
{
	ResetDefect();
}

void CGlass_Data::ResetDefect()
{
	HANDLE hThread = GetCurrentThread();
	CSingleLock localLock(&m_csGlassDefect);
	localLock.Lock();
	SetThreadPriority(hThread, THREAD_PRIORITY_HIGHEST);

	m_nCurDefectIdx_NG = 0;
	m_nCurDefectIdx_OK = 0;
	m_nJudgeDefectCount = 0;
	m_nCurDefectIdx_Total = 0;

	CDefect* pData;
	for (MapDefectIt it = m_MapDefect_NG.begin(); it != m_MapDefect_NG.end(); it++)
	{
		pData = static_cast<CDefect*> (it->second);
		delete pData;
		pData = NULL;
	}
	m_MapDefect_NG.clear();

	for (MapDefectIt it = m_MapDefect_OK.begin(); it != m_MapDefect_OK.end(); it++)
	{
		pData = static_cast<CDefect*> (it->second);
		delete pData;
		pData = NULL;
	}
	m_MapDefect_OK.clear();

	SetThreadPriority(hThread, THREAD_PRIORITY_NORMAL);
	localLock.Unlock();
}

void CGlass_Data::ResetGlass()
{
	ResetDefect();	

	m_strLoadingTime			= _T("");
	m_strUnloadingTime			= _T("");
	m_strScanStartTime			= _T("");
	m_strScanEndTime			= _T("");		
	m_bPostProcessing			= FALSE;

	for(int i=0; i<MAX_DIMENSION_COUNT; i++)
		m_SideData[i].Reset();

	ZeroMemory(m_nStageLongTheta,sizeof(short)*2);
	ZeroMemory(m_nStageShortTheta,sizeof(short)*2);
	ZeroMemory(m_bScanEnd,sizeof(m_bScanEnd));
	m_bScanStart = FALSE;
	m_nStartCount = 0;
	ZeroMemory(m_bScanEndCamera,sizeof(m_bScanEndCamera));

	m_bInspectComplete = FALSE;
	m_bJudgeNG = FALSE;
}

void CGlass_Data::SetScanStart(BOOL bStart)
{
	m_bScanStart = bStart;
}

void CGlass_Data::SetScanEnd(int nScanIdx,BOOL bIsEnd)
{
	m_bScanEnd[nScanIdx] = bIsEnd;
}

BOOL CGlass_Data::GetScanEnd(int nScanIdx)
{
	return m_bScanEnd[nScanIdx];
}

int CGlass_Data::GetScanEndCameraCount()
{
	int			nCount = 0;

	CSingleLock		sLock(&m_csInsEnd);
	sLock.Lock();
	for(int iCam=0;iCam<MAX_CAMERA_COUNT;iCam++)
	{
		for(int iScan=0;iScan<MAX_SCAN_COUNT;iScan++)
		{
			if(m_bScanEndCamera[iCam][iScan] == TRUE)
				nCount++;
		}
	}
	sLock.Unlock();

	return nCount;
}

void CGlass_Data::SetScanEndCamera(int iCam,int iScan)
{
	CSingleLock		sLock(&m_csInsEnd);
	sLock.Lock();
	m_bScanEndCamera[iCam][iScan] = TRUE;
	sLock.Unlock();
}

void CGlass_Data::SetStageNo(int nStageNo)
{
	if(nStageNo < 0 || MAX_STAGE_HAND_COUNT <= nStageNo)
		return;

	nStageNo = nStageNo;
}

CDefect* CGlass_Data::GetDefect_NG(int nDefecIdx)
{
	CDefect	*pDefect = NULL;

	for(MapDefectIt it=m_MapDefect_NG.begin();it!=m_MapDefect_NG.end();it++)
	{
		if (m_nCurDefectIdx_NG > 0)
		{
			pDefect = static_cast<CDefect*>(it->second);
			if (pDefect != NULL && pDefect->m_nIdx == nDefecIdx)
			{
				return pDefect;
			}
		}
	}

	return NULL;
}

CDefect* CGlass_Data::GetDefect_OK(int nDefecIdx)
{
	CDefect	*pDefect = NULL;

	for(MapDefectIt it=m_MapDefect_OK.begin();it!=m_MapDefect_OK.end();it++)
	{
		if (m_nCurDefectIdx_OK > 0)
		{
			pDefect = static_cast<CDefect*>(it->second);
			if (pDefect != NULL && pDefect->m_nIdx == nDefecIdx)
			{
				return pDefect;
			}
		}
	}

	return NULL;
}

BOOL CGlass_Data::TrimString(const CString& strDataInput, std::vector<CString> &arrString, const CString& strSign/*=_T(",")*/) {
	/* code */
	arrString.clear();

	CString strData = strDataInput;
	strData.Trim();  //??3y??óD????μ??é??
	if (strData.IsEmpty()) {
		return TRUE;
	}
	if (-1 == strData.Find(strSign)) {   //2?°üo?·???·?
		arrString.push_back(strData);
		return TRUE;
	}
	while (0 == strData.Find(strSign)) {   //?-?·é?3yê×??é?μ?·???·?
		strData.Delete(0, strSign.GetLength());
	}
	strData += strSign;
	CString str = _T("");
	long lIndex = strData.Find(strSign);
	while (-1 < lIndex)
	{
		str.Empty();
		str = strData.Left(lIndex).Trim();
		if (!str.IsEmpty())
		{
			arrString.push_back(str);
		}
		strData.Delete(0, lIndex + strSign.GetLength());
		lIndex = strData.Find(strSign);
	}
	return TRUE;
}

int CGlass_Data::DecodePose(CString strDirection) {
	/* code */
	USES_CONVERSION;
	std::string strCode(W2A(strDirection));
	if (0 == strCode.compare("C1-L")) {
		return 0;
	}
	else if (0 == strCode.compare("C1-S")) {
		return 1;
	}
	else if (0 == strCode.compare("C1-C2")) {
		return 2;
	}
	else if (0 == strCode.compare("C1-C4")) {
		return 3;
	}
	else if (0 == strCode.compare("C2-L")) {
		return 4;
	}
	else if (0 == strCode.compare("C2-S")) {
		return 5;
	}
	else if (0 == strCode.compare("C2-C3")) {
		return 6;
	}
	else if (0 == strCode.compare("C3-L")) {
		return 7;
	}
	else if (0 == strCode.compare("C3-S")) {
		return 8;
	}
	else if (0 == strCode.compare("C3-C4")) {
		return 9;
	}
	else if (0 == strCode.compare("C4-L")) {
		return 10;
	}
	else if (0 == strCode.compare("C4-S")) {
		return 11;
	}

	return -1;
}

int  CGlass_Data::DecodeDefectPose(CDefect_Info *pDefect, CString& strResult, const int defaultInt) {
	/* code */
	int nRet = defaultInt;
	if (pDefect == NULL) {
		return nRet;
	}

	//1. SideData
	int idx = pDefect->m_nSideIdx;
	CSide_Data *pSideData = &m_SideData[idx];
	if (!pSideData->m_bFindGlassStartLine) {
		return nRet;
	}
	int nStartLine = pSideData->m_nGlassStartLine;

	CSIDE_PARM *pSideParam = &m_pGlassRecipe->m_SideParam[idx];
	int yMinEdge = nStartLine + pSideParam->m_nCenterJudgeArea_StartLine_To_Start_pxl;
	int yMaxEdge = nStartLine + pSideParam->m_nCenterJudgeArea_StartLine_To_End_pxl;
	int yPos = (int)(pDefect->m_ptDefectPos_pxl.y);

	CString strSign = _T("-");
	std::vector<CString> vStrings;
	TrimString(pSideParam->m_strPosDirection, vStrings, strSign);

	if (vStrings.size() < 3) {
		strResult.Format(_T("------"));
		return nRet;
	}

	if (yPos <= yMinEdge) {
		nRet = 0;
		strResult.Format(_T("%s-%s"), vStrings[0], vStrings[2]);
	}
	else if (yPos >= yMaxEdge) {
		nRet = 2;
		strResult.Format(_T("%s-%s"), vStrings[1], vStrings[2]);
	}
	else {
		nRet = 1;
		strResult.Format(_T("%s-%s"), vStrings[0], vStrings[1]);
	}

	nRet = DecodePose(strResult);

	return nRet;
}

int CGlass_Data::PointToLineDistance(CPoint A, CPoint B, CPoint C)
{
	int nDistance = -1;
	int A_coeff = B.y - A.y;
	int B_coeff = A.x - B.x;
	int C_coeff = B.x * A.y - A.x * B.y;

	if (0 == A_coeff && 0 == B_coeff)
	{
		nDistance = std::sqrt((C.y - A.y) * (C.y - A.y) - (C.x - A.x) * (C.x - A.x));
		return nDistance;
	}

	nDistance = std::abs(A_coeff * C.x + B_coeff * C.y + C_coeff) / std::sqrt(A_coeff * A_coeff + B_coeff * B_coeff);
	return nDistance;
}

CPoint CGlass_Data::RotatePoint(CPoint p, double angle)
{
	double rad = angle * M_PI / 180.0;
	double cosAngle = cos(rad);
	double sinAngle = sin(rad);

	CPoint ptRot;
	ptRot.x = static_cast<int>(round(p.x * cosAngle - p.y * sinAngle));
	ptRot.y = static_cast<int>(round(p.x * sinAngle + p.y * cosAngle));
	return ptRot;
}

CPoint CGlass_Data::TransformToGlobal(DimensionDir eDir, CPoint localPoint)
{
	int nGlassSizeY = m_pGlassRecipe->m_SideParam[DIMENSION_A].m_nSidePanelSize_um;
	int nGlassSizeX = m_pGlassRecipe->m_SideParam[DIMENSION_B].m_nSidePanelSize_um;

	std::map<CString, CPoint> corners = {
		{_T("C1"), {0, 0}},
		{_T("C2"), {nGlassSizeX, 0}},
		{_T("C3"), {nGlassSizeX, nGlassSizeY}},
		{_T("C4"), {0, nGlassSizeY}}
	};

	std::vector<CString> vStrings;
	TrimString(m_pGlassRecipe->m_SideParam[eDir].m_strPosDirection, vStrings, _T("-"));

	CPoint globalPoint = { 0, 0 };
	if (vStrings.size() != 3)
		return globalPoint;

	CSide_Data* pSideData = &m_SideData[eDir];
	if (!pSideData->m_bFindGlassStartLine)
		return globalPoint;

	CPoint ptSideEnd = { 0, 0 };
	for (int i = 0; i < MAX_IMAGE_FRAME - 1; i++)
	{
		if (pSideData->m_nSideLineFrame[i + 1] < 0)
		{
			ptSideEnd.x = pSideData->m_nSideLineFrame[i];
			ptSideEnd.y = ((pSideData->m_nGlassEndLine <= 0) ? pSideData->m_nPreGlassEndLine : pSideData->m_nGlassEndLine);
			break;
		}		
	}

	double dAngle = atan2(ptSideEnd.y - pSideData->m_nGlassStartLine, ptSideEnd.x - pSideData->m_nSideLineFrame[0]) * 180.0 / M_PI;
	CPoint ptDefect = RotatePoint(CPoint(localPoint.x - pSideData->m_nSideLineFrame[0], localPoint.y - pSideData->m_nGlassStartLine), 90 - dAngle);
	ptDefect.x *= static_cast<int>(round(pSideData->m_dPixelSizeX));
	ptDefect.y *= static_cast<int>(round(pSideData->m_dPixelSizeY));

	if (ptDefect.x < 0 || ptDefect.y < 0)
		return globalPoint;

	auto itStart = corners.find(vStrings[0]);
	auto itEnd = corners.find(vStrings[1]);
	if (itStart == corners.end() || itEnd == corners.end())
		return globalPoint;

	CPoint ptStart = itStart->second;
	CPoint ptEnd = itEnd->second;
	dAngle = atan2(ptEnd.y - ptStart.y, ptEnd.x - ptStart.x);

	globalPoint.x = ptDefect.y * cos(dAngle) - ptDefect.x * sin(dAngle) + ptStart.x;
	globalPoint.y = ptDefect.y * sin(dAngle) - ptDefect.x * cos(dAngle) + ptStart.y;

	return globalPoint;
}

BOOL CGlass_Data::SetDefect(CDefect* pDefect)
{
	if (pDefect == NULL)
		return FALSE;

	int nSideIdx = pDefect->m_DefectInfo.m_nScanIdx;

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

	CSingleLock localLock(&m_csGlassDefect);
	localLock.Lock();

	m_nCurDefectIdx_Total++;
	m_SideData[nSideIdx].m_nTotalDefectCount++;

	if(pDefect->m_bJudge_NG == TRUE)
	{
		pDefect->m_nIdx = m_nCurDefectIdx_NG;
		m_MapDefect_NG.insert(std::make_pair(pDefect->m_nIdx, pDefect));
		m_nCurDefectIdx_NG++;

		m_SideData[nSideIdx].m_nNgDefectCount++;
		m_nJudgeDefectCount++;
	}
	else
	{
		pDefect->m_nIdx = m_nCurDefectIdx_OK;
		m_MapDefect_OK.insert(std::make_pair(pDefect->m_nIdx, pDefect));
		m_nCurDefectIdx_OK++;
	}

	localLock.Unlock();
	return TRUE;
}

//////////////////////////////////////////////////////////////////////////
// Scan
void CGlass_Data::SetLoadingTime()
{
	CTime	time = CTime::GetCurrentTime();
	m_tLoadingTime = time;
	m_strLoadingTime.Format(_T("%04d%02d%02d_%02d%02d%02d"),time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond());
	m_strLoadingDayFileName.Format(_T("%04d%02d%02d"),time.GetYear(),time.GetMonth(),time.GetDay());
	m_strLoadingTimeFileName.Format(_T("%02d%02d%02d"),time.GetHour(),time.GetMinute(),time.GetSecond());
}

void CGlass_Data::SetUnloadingTime()
{
	CTime	time = CTime::GetCurrentTime();
	m_strUnloadingTime.Format(_T("%04d%02d%02d_%02d%02d%02d"),time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond());
}

void CGlass_Data::SetScanStartTime()
{
	CTime	time = CTime::GetCurrentTime();
	m_strScanStartTime.Format(_T("%04d%02d%02d_%02d%02d%02d"),time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond());
}

void CGlass_Data::SetScanEndTime()
{
	CTime	time = CTime::GetCurrentTime();
	m_strScanEndTime.Format(_T("%04d%02d%02d_%02d%02d%02d"),time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond());
	m_strScanEndTimeFileName.Format(_T("%04d_%02d_%02d"),time.GetYear(),time.GetMonth(),time.GetDay());
	
}

void CGlass_Data::GetStageTheta(int iStage,short &nLongTheta,short &nShortTheta)
{
	nLongTheta = m_nStageLongTheta[iStage];
	nShortTheta = m_nStageShortTheta[iStage];
}

void CGlass_Data::SetStageTheta(int iStage,BOOL bLong,short nTheta)
{
	if(iStage < 0 || iStage > 1)
	{
		g_pLog->DisplayMessage(_T("Stage Theta Index Not Normal : %d"),iStage);
		return;
	}

	if(bLong == TRUE)
	{
		m_nStageLongTheta[iStage] = nTheta;
	}
	else
	{
		m_nStageShortTheta[iStage] = nTheta;
	}
}