#include "stdafx.h"
#include "CornerDistProcess.h"
#include "VisionBufferPro.h"
#include "VisionRecipe.h"

CCornerDistProcess::CCornerDistProcess(){
	/* code */
	m_eDir = DIMENSION_NONE;
	init();
}

CCornerDistProcess::~CCornerDistProcess(){
	/* code */
	release();
}

int CCornerDistProcess::init(void) {
	/* code */
	release();

	m_isTfConvert = FALSE;

	for (int i = 0; i < 6; i++) {
		m_stdPoint[i].x = 0;
		m_stdPoint[i].y = 0;
	}

	for (int i = 0; i < 4; i++) {
		m_aryMeasure[i].idxRefer = 0;
		m_aryMeasure[i].typePoint = 0;
		m_aryMeasure[i].modePoint = 0;
		m_aryMeasure[i].pointThres = 30;
		m_aryMeasure[i].modeNear = 0;
		m_aryMeasure[i].nearThres = 30;
	}

	return 0;
}

void CCornerDistProcess::release(void) {
	/* code */
	int nCount = (int)(m_vDosts.size());
	if (nCount > 0) {
		for (int i = 0; i < nCount; i++) {
			CDistDotProcess *dot = m_vDosts.at(i);
			if (NULL == dot) continue;
			delete dot;
			dot = NULL;
		}
	}
	m_vDosts.clear();
}

CDistDotProcess* CCornerDistProcess::getDot(int index) {
	/* code */
	int nCount = (int)(m_vDosts.size());
	if (index < 0 || index > nCount - 1) return nullptr;

	CDistDotProcess *dot = m_vDosts.at(index);
	return dot;
}

int CCornerDistProcess::addDot(void) {
	/* code */
	int nCount = (int)(m_vDosts.size());
	int id = -MAXINT;
	if (nCount < 1) {
		id = 0;
	}
	else {
		for (int i = 0; i < nCount; i++) {
			CDistDotProcess *dot = m_vDosts.at(i);
			if (NULL == dot) continue;
			if (dot->getID() <= id) continue;
			id = dot->getID();
		}
		id += 1;
	}

	CDistDotProcess *dot = new CDistDotProcess(m_eDir, id);
	m_vDosts.push_back(dot);
	return id;
}

Point2I CCornerDistProcess::getPoint(int nType) {
	/* code */
	Point2I result;
	result.x = 0;
	result.y = 0;
	if (nType < 0 || nType > 5) return result;

	result = m_stdPoint[nType];
	return result;
}

void CCornerDistProcess::setPoint(Point2I pos, int nType) {
	/* code */
	if (nType < 0 || nType > 5) return;

	m_stdPoint[nType] = pos;
}

int CCornerDistProcess::execute(DimensionDir eDir) {
	/* code */
	m_isTfConvert = FALSE;
	if (m_eDir != eDir) return -1;

	int nCount = (int)(m_vDosts.size());
	if (nCount < 1) return 0;

	Point2I offset;
	Point2I pose;
	int idxType = 0;
	MeasureInfo inf;
	for (int i = 0; i < nCount; i++) {
		CDistDotProcess *dot = m_vDosts.at(i);
		if (NULL == dot) continue;

		idxType = dot->m_idxRefer;
		if (idxType < 0 || idxType > 3) continue;
		inf = m_aryMeasure[idxType];

		pose = dot->getPose();
		offset = getOffset(inf.idxRefer, pose);

		dot->setPoint(m_stdPoint[0], 0);
		dot->setPoint(m_stdPoint[1], 1);
		dot->setPoint(tfCoordinate(m_stdPoint[4]), 2);
		dot->setPoint(tfCoordinate(m_stdPoint[5]), 3);
		dot->Execute(m_eDir, inf, offset);
	}

	return 0;
}

int CCornerDistProcess::Serialized(void* pBuffer, int size) {
	/* code */
	char* pTemp = (char*)pBuffer;
	int remainSize = size;
	int useSize = 0;
	int nRet = 0;

#if 0
	//1. ±£´æmark
	int iValue = (int)(m_eDir);
	SERIALIZER_INT_32(iValue, pTemp, remainSize, useSize);   //Type

	for (int i = 0; i < 6; i++) {
		SERIALIZER_INT_32(m_stdPoint[i].x, pTemp, remainSize, useSize);
		SERIALIZER_INT_32(m_stdPoint[i].y, pTemp, remainSize, useSize);
	}

	for (int i = 0; i < 4; i++) {
		SERIALIZER_INT_32(m_aryMeasure[i].idxRefer, pTemp, remainSize, useSize);
		SERIALIZER_INT_32(m_aryMeasure[i].typePoint, pTemp, remainSize, useSize);
		SERIALIZER_INT_32(m_aryMeasure[i].modePoint, pTemp, remainSize, useSize);
		SERIALIZER_INT_32(m_aryMeasure[i].pointThres, pTemp, remainSize, useSize);
		SERIALIZER_INT_32(m_aryMeasure[i].modeNear, pTemp, remainSize, useSize);
		SERIALIZER_INT_32(m_aryMeasure[i].nearThres, pTemp, remainSize, useSize);
	}

	//2. ±£´æµãµÄÊýÁ¿
	int nCount = (int)(m_vDosts.size());
	SERIALIZER_INT_32(nCount, pTemp, remainSize, useSize);

	if (nCount > 0) {
		for (int i = 0; i < nCount; i++) {
			CDistDotProcess *pDot = m_vDosts.at(i);
			if (NULL == pDot) continue;
			nRet = pDot->Serialized(pTemp, remainSize);
			if (nRet < 0) continue;
			pTemp += nRet;
			remainSize -= nRet;
			useSize += nRet;
		}
	}
#endif

	return useSize;
}

int CCornerDistProcess::Deserialized(void* pBuffer, int size) {
	/* code */
	release();

	char* pTemp = (char*)pBuffer;
	int remainSize = size;
	int useSize = 0;
	int nRet = 0;

#if 0
	//1. ¼ÓÔØMark
	int iValue = 0;
	DESERIALIZER_INT_32(iValue, pTemp, remainSize, useSize);   //Type
	m_eDir = (DimensionDir)(iValue);
	
	for (int i = 0; i < 6; i++) {
		DESERIALIZER_INT_32(m_stdPoint[i].x, pTemp, remainSize, useSize);
		DESERIALIZER_INT_32(m_stdPoint[i].y, pTemp, remainSize, useSize);
	}

	for (int i = 0; i < 4; i++) {
		DESERIALIZER_INT_32(m_aryMeasure[i].idxRefer, pTemp, remainSize, useSize);
		DESERIALIZER_INT_32(m_aryMeasure[i].typePoint, pTemp, remainSize, useSize);
		DESERIALIZER_INT_32(m_aryMeasure[i].modePoint, pTemp, remainSize, useSize);
		DESERIALIZER_INT_32(m_aryMeasure[i].pointThres, pTemp, remainSize, useSize);
		DESERIALIZER_INT_32(m_aryMeasure[i].modeNear, pTemp, remainSize, useSize);
		DESERIALIZER_INT_32(m_aryMeasure[i].nearThres, pTemp, remainSize, useSize);
	}

	//2. ±£´æµãµÄÊýÁ¿
	int nCount = 0;
	DESERIALIZER_INT_32(nCount, pTemp, remainSize, useSize);

	for (int i = 0; i < nCount; i++) {
		CDistDotProcess *dot = new CDistDotProcess();
		nRet = dot->Deserialized(pTemp, remainSize);
		if (nRet < 0) continue;
		m_vDosts.push_back(dot);

		pTemp += nRet;
		remainSize -= nRet;
		useSize += nRet;
	}

#endif


	return useSize;
}

std::vector<CDistDotProcess*>& CCornerDistProcess::getDots(void) {
	/* code */
	return m_vDosts;
}

int CCornerDistProcess::delDot(int id) {
	/* code */
	int nCount = (int)(m_vDosts.size());
	if (nCount < 1) return -1;
	bool isFind = false;
	for (auto iter = m_vDosts.begin(); iter != m_vDosts.end(); iter++) {
		CDistDotProcess *dot = (*iter);
		if (id == (*iter)->getID()) {
			isFind = true;
			m_vDosts.erase(iter);
			break;
		}
	}
	if (!isFind) return -1;

	nCount = (int)(m_vDosts.size());
	if (nCount < 1) return -1;

	CDistDotProcess *dot = m_vDosts.at(0);
	return dot->getID();
}

Point2I CCornerDistProcess::getOffset(int nType, Point2I pt) {
	/* code */
	Point2I result;
	result.x = 0;
	result.y = 0;

	switch (nType){
	case 1:
		result = getTopPointOffset(pt);
		break;

	case 2:
		result = getBotPointOffset(pt);
		break;

	default:
		result = getAffineOffset(pt);
		break;
	}

	return result;
}

MeasureInfo CCornerDistProcess::getMeasureInfo(int index) {
	/* code */
	MeasureInfo inf;
	inf.idxRefer = 0;
	inf.typePoint = 0;
	inf.modePoint = 0;
	inf.pointThres = 30;
	inf.modeNear = 0;
	inf.nearThres = 30;
	if (index < 0 || index > 3) return inf;

	inf = m_aryMeasure[index];
	return inf;
}

void CCornerDistProcess::setMeasureInfo(MeasureInfo inf, int index) {
	/* code */
	if (index < 0 || index > 3) return;

	m_aryMeasure[index] = inf;
}

Point2I CCornerDistProcess::getAffineOffset(Point2I pt) {
	/* code */
	Point2I result;
	Point2I ptTarget = tfCoordinate(pt);

	result.x = (int)(ptTarget.x - pt.x);
	result.y = (int)(ptTarget.y - pt.y);

	return result;
}

Point2I CCornerDistProcess::tfCoordinate(Point2I pt) {
	/* code */
	tfProcess();

	Point2D pose;
	pose.x = pt.x;
	pose.y = pt.y;
	Point2D ptTarget = ClsVision::CoordinateTransform(pose, m_affine);
	Point2I result;
	result.x = (int)(ptTarget.x);
	result.y = (int)(ptTarget.y);
	return result;
}

void CCornerDistProcess::tfProcess(void){
	/* code */
	if (m_isTfConvert) return;

	CBlSideData *pSideData = CVisionRecipe::getInstance()->getSideData(m_eDir);
	if (NULL == pSideData) {
		Point2D pose;
		pose.x = 0.0f;
		pose.y = 0.0f;
		m_affine = ClsVision::VectorAngleToRigid(pose, 0.0f, pose, 0.0f);
		return;
	}

	std::vector<Point2D> vPtOrg, vPtTgt;
	Point2D pose;
	pose.x = m_stdPoint[0].x;
	pose.y = m_stdPoint[0].y;
	vPtOrg.push_back(pose);
	pose.x = m_stdPoint[1].x;
	pose.y = m_stdPoint[1].y;
	vPtOrg.push_back(pose);

	pose.x = pSideData->m_mTopMark.x;
	pose.y = pSideData->m_mTopMark.y;
	vPtTgt.push_back(pose);
	pose.x = pSideData->m_mBotMark.x;
	pose.y = pSideData->m_mBotMark.y;
	vPtTgt.push_back(pose);

	m_affine = ClsVision::VectorToSimilarity(vPtOrg, vPtTgt);
	m_isTfConvert = TRUE;
}

Point2I CCornerDistProcess::getTopPointOffset(Point2I pt) {
	/* code */
	Point2I result;
	result.x = 0;
	result.y = 0;
	CBlSideData *pSideData = CVisionRecipe::getInstance()->getSideData(m_eDir);
	if (NULL == pSideData) return result;

	if (!pSideData->m_bTopPoint_Find) return result;

	result.x = pSideData->m_mTopPoint.x - m_stdPoint[2].x;
	result.y = pSideData->m_mTopPoint.y - m_stdPoint[2].y;

	return result;
}

Point2I CCornerDistProcess::getBotPointOffset(Point2I pt) {
	/* code */
	Point2I result;
	result.x = 0;
	result.y = 0;
	CBlSideData *pSideData = CVisionRecipe::getInstance()->getSideData(m_eDir);
	if (NULL == pSideData) return result;

	if (!pSideData->m_bBotPoint_Find) return result;

	result.x = pSideData->m_mBotPoint.x - m_stdPoint[3].x;
	result.y = pSideData->m_mBotPoint.y - m_stdPoint[3].y;

	return result;
}