#include "StdAfx.h"
#include "CameraControlReview.h"
#include "CHImageControls/CHImageProcess.h"
#include "ReviewProcessor.h"

using namespace CHImageControls;

CCameraControlReview::CCameraControlReview(int nModuleIndex, int nLensType)
{
	m_nViewMode = View_Live;
	m_nControlType = 0;
	m_nModuleIndex = nModuleIndex;
	m_nLensType = nLensType;
	m_nZoomLevel = 0;
	m_bDigitalZoom = FALSE;
	m_nReviewPointCount = 0;
	m_pRCC2P = NULL;

	m_nReviewProcessStatus	= ReviewProcessStatus_None; 
	m_nReviewPlanIndex		= 0;

	m_rtSubRect = CRect(738,619,1718,1439);
	
	m_vecAlignFinder.clear();

	m_nResizeWidth = 2464;
	m_nResizeHeight = 2056;
}

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

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

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

	CAlignFinder *pFinder = NULL;
	pFinder = new CAlignFinder();
	m_vecAlignFinder.push_back(pFinder);

	return TRUE;
}

int	CCameraControlReview::Camera_Control(int nControlType)
{
	int nRetValue = 0;

	if ((nRetValue=CCameraController::Camera_Control(nControlType))==1)
	{
		m_nControlType = nControlType;
	}

	if (m_pRCC2P)
	{
		m_pRCC2P->IRCC2P_CameraControl(m_nModuleIndex, m_nControlType);
	}

	return nRetValue;
}

void CCameraControlReview::SetDigitalZoomInfo(const CRect& rtSubRect, int nResizeWidth, int nResizeHeight)
{
	if (nResizeWidth<1 || nResizeHeight<1) return;
	if (rtSubRect.Width()<1 || rtSubRect.Height()<1) return;

	m_rtSubRect = rtSubRect;
	m_nResizeWidth = nResizeWidth;
	m_nResizeHeight = nResizeHeight;
}

// camera control 2 parent
BOOL CCameraControlReview::ICC2P_GetCurrentFrame(int nCameraIndex, int nFrameWidth, int nFrameHeight, int nFrameChannels,  CCHImageData* pImageData)
{
	if (m_pRCC2P==NULL) return FALSE;

	return  m_pRCC2P->IRCC2P_GetCurrentFrame(m_nModuleIndex, nCameraIndex, nFrameWidth, nFrameHeight, nFrameChannels, pImageData);
}

BOOL CCameraControlReview::ICC2P_FrameCaptured(int nCameraIndex, int nFrameIndex, int nFrameCount)
{
	if (!CCameraController::ICC2P_FrameCaptured(nCameraIndex, nFrameIndex, nFrameCount))
	{
		return FALSE;
	}

	if (!m_pRCC2P) return FALSE;

	// CameraStart 일때만 리뷰이미지 결과 전송하자
	if (m_nControlType==CameraControlStart)
	{
		SendReviewResult(nCameraIndex, m_vecCameraImageIndex[nCameraIndex]);
	}

	nFrameIndex = m_vecCameraImageIndex[nCameraIndex];

//???뭘까	if (nCameraIndex==m_nZoomLevel) // zoom index check
	{
		// digital zoom?
		if ( m_bDigitalZoom && (m_nResizeWidth>0&&m_nResizeHeight>0) )
		{
			CCHImageData subImage;
			if (((m_vecCameraImage[nCameraIndex])->GetImageData(nFrameIndex))->GetSubImage(m_rtSubRect, &subImage))
			{
				CCHImageData resizeImage;
				if (CCHImageProcess::ImageResize(&subImage, &resizeImage, m_nResizeWidth, m_nResizeHeight)==ResultSuccess)
				{
					m_pRCC2P->IRCC2P_FrameCaptured(m_nModuleIndex, nCameraIndex, nFrameIndex, &resizeImage);
				}
			}
		}
		else // not digital zoom
		{
			m_pRCC2P->IRCC2P_FrameCaptured(m_nModuleIndex, nCameraIndex, nFrameIndex, (m_vecCameraImage[nCameraIndex])->GetImageData(nFrameIndex));
		}
	}

	return TRUE;
}

void CCameraControlReview::SendReviewResult(int nCameraIndex, int nPointIndex)
{
	if (++m_vecCameraImageCount[nPointIndex] >= GetCameraCount())
	{
		VectorImageData vectorImageData;
		for (int i=0; i<(int)m_vecCameraImageIndex.size(); i++)
		{
			CCHImageData* pImageData = m_vecCameraImage[i]->GetImageData(nPointIndex);
			vectorImageData.push_back(pImageData);
		}

		m_pRCC2P->IRCC2P_ReviewResult(m_nModuleIndex, nPointIndex, vectorImageData);
	}
}

void CCameraControlReview::UpdateCameraControl(int nModuleIndex, const SCameraControl* pCameraControl, const SCameraInfo* pCameraInfo)
{
	if (pCameraControl==NULL) return;

	if (m_nModuleIndex!=nModuleIndex) return;

	if(m_nLensType != 0)
	{
		m_nZoomLevel = pCameraControl->nZoomLevel; // 듀얼튜브 & 리볼버 둘다 대응된게 변경 필요.
	}
	m_bDigitalZoom = pCameraControl->bDigitalZoom;
	
}

void CCameraControlReview::UpdateReviewProcessStatus(int nReviewStatus, int nPlanIndex)
{
	m_nReviewProcessStatus	= nReviewStatus;
	m_nReviewPlanIndex		= nPlanIndex;
}

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

	switch(nProcessStatus)
	{
	case ProcessReviewStart:
		if (pGlassResult->GetReadRawFile())
		{
			m_nReviewPointCount = pGlassResult->GetSReviewResultCount(m_nModuleIndex);
			g_pLog->DisplayMessage(_T("[CameraControlReview] ViewIdx[%d] ReviewPoint[%d]"), m_nModuleIndex, m_nReviewPointCount);
		}
		break;
	}

}

BOOL CCameraControlReview::FindReviewAlignMark(double &dPosX, double &dPosY, double dRatio)
{
	CCameraImageData* pCameraImage = m_vecCameraImage[0];
	CAlignFinder* pAlignFinder = m_vecAlignFinder[0];

	if (pCameraImage==NULL || pAlignFinder==NULL) return FALSE;

	// Set Param
	SAlignFindParam findParam;
	findParam.bMatchProcess			= m_AlignRecipe.bUseImage;
	findParam.dMatchRate			= m_AlignRecipe.dMatchingRate;

	findParam.bEdgeProcess			= m_AlignRecipe.bUseEdge;
	findParam.nAlignWidth			= m_AlignRecipe.nEdgeWidth * dRatio;		// AlignCamera 대비 ReviewCamera 해상도 비율만큼 곱함!!
	findParam.nAlignHeight			= m_AlignRecipe.nEdgeHeight * dRatio;
	findParam.nEdgeThreshold		= m_AlignRecipe.nEdgeThreshold;
	findParam.nMergeRange			= m_AlignRecipe.nMergeRange;
	findParam.dEdgeRate				= m_AlignRecipe.dEdgeRate;

	CCHImageData imageCamera;
	int nFrameIndex = m_vecCameraImageIndex[0]<0 ? 0 : m_vecCameraImageIndex[0];
	if ((pCameraImage->GetImageData(nFrameIndex))->GetBandImage(BandTypeGray, &imageCamera)==FALSE)	return FALSE;
	CString strPath =m_pRCC2P->IRCC2P_GetTotalPitchImageName();

	if(strPath == _T("")){
		strPath = _T("D:\\DIT_Review\\Recipe\\AlignImage\\ReviewAlign.bmp");
		//strPath = _T("C:\\DIT_Review\\Recipe\\AlignImage\\ReviewAlign.bmp");  //210805
	}
	else
	{
		strPath = _T("D:\\DIT_Review\\Recipe\\AlignImage\\") + strPath; 
		//strPath = _T("C:\\DIT_Review\\Recipe\\AlignImage\\")+strPath; //210805

	}
	
	
	// TempImage Load
	CCHImageData TempImage;
	if(TempImage.LoadImage(strPath) == FALSE) 
	{
		g_pLog->DisplayMessage(_T("TempImage Load Fail!!"));
		return FALSE;
	}

	// TempImage Gray
	CCHImageData TempGrayImage;
	if(TempImage.GetBandImage(BandTypeGray, &TempGrayImage) == FALSE)	return FALSE;

	//imageCamera.SaveImage(_T("C:\\DIT_Review\\Recipe\\AlignImage\\ReviewAlign2.bmp"));
	//TempGrayImage.SaveImage(_T("C:\\DIT_Review\\Recipe\\AlignImage\\ReviewAlign3.bmp"));

	// find process
	SAlignFindResult findResult = pAlignFinder->FindAlign(&imageCamera, findParam, &TempGrayImage);

	// result process
	int nResultSuccessCode = 0;
	if (findResult.nResultProcess == AlignProcess_Edge)
		nResultSuccessCode = AlignEdge_Success;
	else
		nResultSuccessCode = AlignMatch_Success;

	if (findResult.nResultCode==nResultSuccessCode)
	{
		dPosX = findResult.dPosX;
		dPosY = findResult.dPosY;		

		g_pLog->DisplayMessage(_T("Review Camera Template Matching Success, MatchingRate : %.3lf, PosX : %.3lf, PosY : %.3lf!!"), findResult.dMatchValue, dPosX, dPosY);
	}
	else
	{
		g_pLog->DisplayMessage(_T("Review Camera Template Matching Fail!!!"));
		return FALSE;
	}

	return TRUE;
}