#include "stdafx.h"
#include "DistDotProcess.h"
#include "VisionBufferPro.h"

CDistDotProcess::CDistDotProcess(){
	/* code */
	m_id = 0;
	m_eDir = DIMENSION_A;
	m_strName.Format(_T("P%d"), m_id);

	m_idxRefer = 0;
	m_nRef = 100;
	m_nRef_ = 100;

	m_distMode = 1;
	m_minValue = 0;
	m_maxValue = 0;

	m_distMode2 = 5;
	m_minValue2 = 0;
	m_maxValue2 = 0;

	m_xPos = 0.0f;
	m_yPos = 0.0f;
	m_cx = 0.0f;
	m_cy = 0.0f;
	m_angle = 0.0f;
	m_len1 = 0.0f;
	m_len2 = 0.0f;

	m_xMmvsp = 0.0f;
	m_yMmvsp = 0.0f;
	m_ngType = DefectLoc_Grind;
	m_ngType2 = DefectLoc_Dist_Cut;
	m_incValue = 0;
	m_incValue2 = 0;

	ClsVision::GenEmptyObject(m_hRegion);
	ClsVision::GenEmptyObject(m_hLineRegion);
}

CDistDotProcess::~CDistDotProcess(){
	/* code */
}

CDistDotProcess::CDistDotProcess(DimensionDir eDir, int id) {
	/* code */
	m_id = id;
	m_eDir = eDir;
	switch (eDir){
	case GLOBAL_DEFINE::DIMENSION_A:
		m_strName.Format(_T("TopA%d"), m_id);
		break;
	case GLOBAL_DEFINE::DIMENSION_B:
		m_strName.Format(_T("TopB%d"), m_id);
		break;
	case GLOBAL_DEFINE::DIMENSION_C:
		m_strName.Format(_T("TopC%d"), m_id);
		break;
	case GLOBAL_DEFINE::DIMENSION_D:
		m_strName.Format(_T("TopD%d"), m_id);
		break;
	case GLOBAL_DEFINE::DIMENSION_A_DN:
		m_strName.Format(_T("BotA%d"), m_id);
		break;
	case GLOBAL_DEFINE::DIMENSION_B_DN:
		m_strName.Format(_T("BotB%d"), m_id);
		break;
	case GLOBAL_DEFINE::DIMENSION_C_DN:
		m_strName.Format(_T("BotC%d"), m_id);
		break;
	case GLOBAL_DEFINE::DIMENSION_D_DN:
		m_strName.Format(_T("BotD%d"), m_id);
		break;
	case GLOBAL_DEFINE::DIMENSION_NONE:
		m_strName.Format(_T("P%d"), m_id);
		break;
	default:
		m_strName.Format(_T("P%d"), m_id);
		break;
	}

	m_idxRefer = 0;
	m_nRef = 100;
	m_nRef_ = 100;

	m_distMode = 1;
	m_minValue = 0;
	m_maxValue = 0;

	m_distMode2 = 5;
	m_minValue2 = 0;
	m_maxValue2 = 0;

	m_xPos = 0.0f;
	m_yPos = 0.0f;
	m_cx = 0.0f;
	m_cy = 0.0f;
	m_angle = 0.0f;
	m_len1 = 0.0f;
	m_len2 = 0.0f;

	m_xMmvsp = 0.0f;
	m_yMmvsp = 0.0f;
	m_incValue = 0;
	m_incValue2 = 0;

	ClsVision::GenEmptyObject(m_hRegion);
	ClsVision::GenEmptyObject(m_hLineRegion);

	m_ngType = DefectLoc_Grind;
	m_ngType2 = DefectLoc_Dist_Cut;
}

int CDistDotProcess::getID(void) {
	/* code */
	return m_id;
}

int CDistDotProcess::Execute(DimensionDir eDir, MeasureInfo inf, Point2I offset) {
	/* code */
	m_nNgInfo.clear();
	m_ptMatchResult.x = 0.0f;
	m_ptMatchResult.y = 0.0f;
	m_ptNearResult.x = 0.0f;
	m_ptNearResult.y = 0.0f;
	m_ptMeasureResult.x = 0.0f;
	m_ptMeasureResult.y = 0.0f;
	m_locPointResult.x = 0;
	m_locPointResult.y = 0;

	getMmvsp(eDir);

	getKeyPose(offset);

	//²éÕұ߽ç
	int nRet = findPairEdge(eDir, inf, offset);
//	if (0 != nRet) return nRet;

	JudgeResult();

	return nRet;
}

void CDistDotProcess::JudgeResult(void) {
	/* code */
	JudgeFirstResult();

	JudgeSecondResult();
}

void CDistDotProcess::JudgeFirstResult(void) {
	/* code */
	if (0 == m_distMode) return;

	NgDotInfo ng;
	ng.eDir = m_eDir;
	ng.id = m_id;
	ng.isRes = true;
	ng.minValue = m_minValue;
	ng.maxValue = m_maxValue;
	ng.strName = m_strName;
	ng.ngType = DefectLoc_OK;   //ȱÏÝÀàÐÍ
	ng.eVision = VISION_NONE; // VISION_DIST;

	ng.xPosPxl = m_locPointResult.x;
	ng.yPosPxl = m_locPointResult.y;
	ng.xResult = 0.0f;
	ng.yResult = 0.0f;
	ng.x1 = m_locPointResult.x - 40;
	ng.y1 = m_locPointResult.y - 20;
	ng.x2 = m_locPointResult.x + 40;
	ng.y2 = m_locPointResult.y + 20;
	
	if (1 == m_distMode) {          //Grind Size
		ng.ngType = m_ngType;
		double dx = m_xMmvsp *(m_ptMeasureResult.x - m_ptNearResult.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - m_ptNearResult.y);
		ng.result = sqrt(dx * dx + dy * dy);
	}
	else if (2 == m_distMode) {     //Top Point
		ng.ngType = m_ngType;
		double dx = m_xMmvsp *(m_ptMeasureResult.x - m_topPoint.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - m_topPoint.y);
		ng.result = sqrt(dx * dx + dy * dy);
	}
	else if (3 == m_distMode) {     //Bot Point
		ng.ngType = m_ngType;
		double dx = m_xMmvsp *(m_ptMeasureResult.x - m_botPoint.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - m_botPoint.y);
		ng.result = sqrt(dx * dx + dy * dy);
	}
	else if (4 == m_distMode) {     //Key Dist
		ng.ngType = m_ngType;
		double dx = m_xMmvsp *(m_ptMeasureResult.x - m_ptMatchResult.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - m_ptMatchResult.y);
		ng.result = sqrt(dx * dx + dy * dy);
	}
	else if (5 == m_distMode) {     //Mark Line
		Line2D line;
		line.pt0.x = m_topMark.x;
		line.pt0.y = m_topMark.y;
		line.pt1.x = m_botMark.x;
		line.pt1.y = m_botMark.y;
		Point2D pose = ClsVision::ProjectionPL(m_ptMeasureResult, line);
		double dx = m_xMmvsp *(m_ptMeasureResult.x - pose.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - pose.y);
		ng.result = sqrt(dx * dx + dy * dy);
		ng.ngType = m_ngType;
	}
	if (ng.result + m_incValue > 0.0f) {
		ng.result += m_incValue;
	}
	if (m_maxValue < 0.01f || m_maxValue <= m_minValue + 0.001) {
		m_nNgInfo.push_back(ng);
		return;
	}

	if (ng.result < m_minValue || ng.result > m_maxValue) {
		ng.isRes = false;
	}
	m_nNgInfo.push_back(ng);
}

void CDistDotProcess::JudgeSecondResult(void) {
	/* code */
	if (0 == m_distMode2) return;

	NgDotInfo ng;
	ng.eDir = m_eDir;
	ng.id = m_id;
	ng.isRes = true;
	ng.minValue = m_minValue2;
	ng.maxValue = m_maxValue2;
	ng.strName = m_strName;
	ng.ngType = DefectLoc_OK;   //ȱÏÝÀàÐÍ
	ng.eVision = VISION_NONE;   // VISION_DIST;

	ng.xPosPxl = m_locPointResult.x;
	ng.yPosPxl = m_locPointResult.y;
	ng.xResult = 0.0f;
	ng.yResult = 0.0f;
	ng.x1 = m_locPointResult.x - 40;
	ng.y1 = m_locPointResult.y - 20;
	ng.x2 = m_locPointResult.x + 40;
	ng.y2 = m_locPointResult.y + 20;

	if (1 == m_distMode2) {          //Grind Size
		ng.ngType = m_ngType2;
		double dx = m_xMmvsp *(m_ptMeasureResult.x - m_ptNearResult.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - m_ptNearResult.y);
		ng.result = sqrt(dx * dx + dy * dy);
	}
	else if (2 == m_distMode2) {     //Top Point
		ng.ngType = m_ngType2;
		double dx = m_xMmvsp *(m_ptMeasureResult.x - m_topPoint.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - m_topPoint.y);
		ng.result = sqrt(dx * dx + dy * dy);
	}
	else if (3 == m_distMode2) {     //Bot Point
		ng.ngType = m_ngType2;
		double dx = m_xMmvsp *(m_ptMeasureResult.x - m_botPoint.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - m_botPoint.y);
		ng.result = sqrt(dx * dx + dy * dy);
	}
	else if (4 == m_distMode2) {     //Key Dist
		ng.ngType = m_ngType2;
		double dx = m_xMmvsp *(m_ptMeasureResult.x - m_ptMatchResult.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - m_ptMatchResult.y);
		ng.result = sqrt(dx * dx + dy * dy);
	}
	else if (5 == m_distMode2) {     //Mark Line
		Line2D line;
		line.pt0.x = m_topMark.x;
		line.pt0.y = m_topMark.y;
		line.pt1.x = m_botMark.x;
		line.pt1.y = m_botMark.y;
		Point2D pose = ClsVision::ProjectionPL(m_ptMeasureResult, line);
		double dx = m_xMmvsp *(m_ptMeasureResult.x - pose.x);
		double dy = m_yMmvsp *(m_ptMeasureResult.y - pose.y);
		ng.result = sqrt(dx * dx + dy * dy);
		ng.ngType = m_ngType2;
	}

	if (ng.result + m_incValue2 > 0.0f) {
		ng.result += m_incValue2;
	}
	if (m_maxValue2 < 0.01f || m_maxValue2 <= m_minValue2 + 0.001) {
		m_nNgInfo.push_back(ng);
		return;
	}

	if (ng.result < m_minValue2 || ng.result > m_maxValue2) {
		ng.isRes = false;
	}
	m_nNgInfo.push_back(ng);
}


void CDistDotProcess::getMmvsp(DimensionDir eDir) {
	/* code */
	CBlSideData *pSideData = CVisionRecipe::getInstance()->getSideData(eDir);
	m_xMmvsp = pSideData->m_dPixelSizeX;
	m_yMmvsp = pSideData->m_dPixelSizeY;
}

int CDistDotProcess::getKeyPose(Point2I offset) {
	/* code */
	if (fabs(m_xPos) < 0.01 || fabs(m_yPos) < 0.01) return -1;

	m_ptMatchResult.x = m_xPos + offset.x;
	m_ptMatchResult.y = m_yPos + offset.y;
	return 0;
}

int CDistDotProcess::findPairEdge(DimensionDir eDir, MeasureInfo infMeasure, Point2I offset) {
	/* code */
	//1. ͼÏñÔ¤´¦Àí
	if (m_len1 < 0.01 || m_len2 < 0.01) return -3;

	Line2D line = GetTargeLine();
	line.pt0.x += offset.x;
	line.pt0.y += offset.y;
	line.pt1.x += offset.x;
	line.pt1.y += offset.y;

	int x1 = (int)(line.pt0.x - 30);
	if (line.pt0.x > line.pt1.x)  x1 = (int)(line.pt1.x - 30);
	int x2 = (int)(line.pt0.x + 30);
	if (line.pt0.x < line.pt1.x)  x2 = (int)(line.pt1.x + 30);
	int y1 = (int)(line.pt0.y - 30);
	if (line.pt0.y > line.pt1.y)  y1 = (int)(line.pt1.y - 30);
	int y2 = (int)(line.pt0.y + 30);
	if (line.pt0.y < line.pt1.y)  y2 = (int)(line.pt1.y + 30);
	int leftPos = x1;
	int topPos = y1;

	m_locPointResult.x = (int)(m_cx + offset.x);
	m_locPointResult.y = (int)(m_cy + offset.y);

	HalconCpp::HObject hImage;
	if (!CVisionBufferPro::getImageROI(eDir, hImage, x1, y1, x2, y2)) return -3;
	line.pt0.x -= leftPos;
	line.pt0.y -= topPos;
	line.pt1.x -= leftPos;
	line.pt1.y -= topPos;

//	HalconCpp::HObject hProcImage;
//	HalconCpp::MedianImage(hImage, &hProcImage, "circle", 1, "mirrored");
	bool valid = false;
	if (0 == infMeasure.typePoint) {
		//valid = CVisionBufferPro::GetMeasurePos(hImage, line,
		//	infMeasure.typePoint,
		//	infMeasure.pointThres, infMeasure.modePoint,
		//	infMeasure.nearThres, infMeasure.modeNear, 
		//	5, m_ptMeasureResult, m_ptNearResult);
	}
	else {
		//valid = CVisionBufferPro::GetMeasurePos(hImage, line,
		//	infMeasure.typePoint,
		//	infMeasure.pointThres, infMeasure.modePoint,
		//	infMeasure.nearThres, infMeasure.modeNear,
		//	5, m_ptNearResult, m_ptMeasureResult);
	}
	if (!valid) {
		m_ptMeasureResult.x = 0.0f;
		m_ptMeasureResult.y = 0.0f;
		m_ptNearResult.x = 0.0f;
		m_ptNearResult.y = 0.0f;
	}
	else {
		m_ptMeasureResult.x += leftPos;
		m_ptMeasureResult.y += topPos;
		m_ptNearResult.x += leftPos;
		m_ptNearResult.y += topPos;
	}

	if (!valid) {
		return -4;
	}

	m_locPointResult.x = (int)(m_ptMeasureResult.x);
	m_locPointResult.y = (int)(m_ptMeasureResult.y);

	return 0;
}

Line2D CDistDotProcess::GetTargeLine(void) {
	/* code */
	Line2D lineResult;
	double angle = m_angle;
	double xa = m_len1;
	double xb = m_len2;
	double x = m_cx;
	double y = m_cy;
	Point2D ptCenter;
	ptCenter.x = x;
	ptCenter.y = y;

	double phi = ClsVision::DegreeToRad(angle);
	double cosx = ClsVision::GetCos(phi);
	double sinx = ClsVision::GetSin(phi);

	lineResult.pt0.x = ptCenter.x + xa * cosx;
	lineResult.pt0.y = ptCenter.y - xa * sinx;
	lineResult.pt1.x = 2 * ptCenter.x - lineResult.pt0.x;
	lineResult.pt1.y = 2 * ptCenter.y - lineResult.pt0.y;
	return lineResult;
}

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

#if 0
	//1. ±£´æIDºÍÃû³Æ
	int iValue = (int)(m_eDir);
	SERIALIZER_INT_32(iValue, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_id, pTemp, remainSize, useSize);
	std::string strName(CT2A(m_strName.GetString()));
	SERIALIZER_STRING(strName, pTemp, remainSize, useSize);

	//2. ±£´æÇøÓò·¶Î§
	SERIALIZER_DOUBLE(m_xPos, pTemp, remainSize, useSize);
	SERIALIZER_DOUBLE(m_yPos, pTemp, remainSize, useSize);

	SERIALIZER_DOUBLE(m_cx, pTemp, remainSize, useSize);
	SERIALIZER_DOUBLE(m_cy, pTemp, remainSize, useSize);
	SERIALIZER_DOUBLE(m_angle, pTemp, remainSize, useSize);
	SERIALIZER_DOUBLE(m_len1, pTemp, remainSize, useSize);
	SERIALIZER_DOUBLE(m_len2, pTemp, remainSize, useSize);

	SERIALIZER_INT_32(m_idxRefer, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_nRef, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_nRef_, pTemp, remainSize, useSize);

	SERIALIZER_INT_32(m_distMode, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_minValue, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_maxValue, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_ngType, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_incValue, pTemp, remainSize, useSize);

	SERIALIZER_INT_32(m_distMode2, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_minValue2, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_maxValue2, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_ngType2, pTemp, remainSize, useSize);
	SERIALIZER_INT_32(m_incValue2, pTemp, remainSize, useSize);
#endif

	return useSize;
}

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

#if 0
	//1. ±£´æIDºÍÃû³Æ
	int iValue = 0;
	DESERIALIZER_INT_32(iValue, pTemp, remainSize, useSize);
	m_eDir = (DimensionDir)(iValue);
	DESERIALIZER_INT_32(m_id, pTemp, remainSize, useSize);
	std::string strName; 
	DESERIALIZER_STRING(strName, pTemp, remainSize, useSize);
	m_strName = CA2T(strName.c_str());

	//2. ±£´æÇøÓò·¶Î§
	DESERIALIZER_DOUBLE(m_xPos, pTemp, remainSize, useSize);
	DESERIALIZER_DOUBLE(m_yPos, pTemp, remainSize, useSize);

	DESERIALIZER_DOUBLE(m_cx, pTemp, remainSize, useSize);
	DESERIALIZER_DOUBLE(m_cy, pTemp, remainSize, useSize);
	DESERIALIZER_DOUBLE(m_angle, pTemp, remainSize, useSize);
	DESERIALIZER_DOUBLE(m_len1, pTemp, remainSize, useSize);
	DESERIALIZER_DOUBLE(m_len2, pTemp, remainSize, useSize);

	DESERIALIZER_INT_32(m_idxRefer, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_nRef, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_nRef_, pTemp, remainSize, useSize);

	DESERIALIZER_INT_32(m_distMode, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_minValue, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_maxValue, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_ngType, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_incValue, pTemp, remainSize, useSize);

	DESERIALIZER_INT_32(m_distMode2, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_minValue2, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_maxValue2, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_ngType2, pTemp, remainSize, useSize);
	DESERIALIZER_INT_32(m_incValue2, pTemp, remainSize, useSize);

	if (m_xPos <= 0.001 && m_yPos <= 0.001) {
		HalconCpp::GenEmptyObj(&m_hRegion);
	}
	else {
		HalconCpp::GenCircle(&m_hRegion, m_yPos, m_xPos, 25);
	}

	if (m_len1 < 0.01 || m_len2 < 0.01) {
		HalconCpp::GenEmptyObj(&m_hRegion);
	}
	else {
		HalconCpp::GenRectangle2(&m_hLineRegion, m_cy, m_cx, ClsVision::DegreeToRad(m_angle), m_len1, m_len2);
	}
#endif
	
	return useSize;
}

void CDistDotProcess::setRoiRegion(HalconCpp::HObject &hRegion) {
	/* code */
	m_xPos = 0.0f;
	m_yPos = 0.0f;
	if (!ClsVision::RegionExist(hRegion)){
		HalconCpp::GenEmptyObj(&m_hRegion);
		return;
	}

	int nArea = 0;
	ClsVision::AreaCenter(hRegion, nArea, m_xPos, m_yPos);
	m_hRegion = hRegion;
}

void CDistDotProcess::setLineRegion(HalconCpp::HObject &hRegion) {
	/* code */
	m_cx = 0.0f;
	m_cy = 0.0f;
	m_angle = 0.0f;
	m_len1 = 0.0f;
	m_len2 = 0.0f;
	if (!ClsVision::RegionExist(hRegion)) {
		HalconCpp::GenEmptyObj(&m_hLineRegion);
		return;
	}

	ClsVision::SmallestRectangle2(hRegion, m_cx, m_cy, m_angle, m_len1, m_len2);
	m_hLineRegion = hRegion;
}

Point2I CDistDotProcess::getPose(void) {
	/* code */
	Point2I result;
	result.x = (int)(m_cx);
	result.y = (int)(m_cy);
	return result;
}

void CDistDotProcess::setPoint(Point2I pt, int nType) {
	/* code */
	if (0 == nType) {
		m_topMark = pt;
	}
	else if (1 == nType) {
		m_botMark = pt;
	}
	else if (2 == nType) {
		m_topPoint = pt;
	}
	else if (3 == nType) {
		m_botPoint = pt;
	}
}