#include "stdafx.h"
#include "VisionBufferPro.h"
#include "Bspline.h"

#define  DEFAULTT_IMAGE_HEIGHT     100000

CVisionBufferPro::CVisionBufferPro()
{
}

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

bool CVisionBufferPro::bufferToObject(DimensionDir eDir, int height, HalconCpp::HObject &hImage) {
	/* code */
	CVisionRecipe *pRecipe = CVisionRecipe::getInstance();
	int iCam = pRecipe->getCameraIndex(eDir);
	int iScan = pRecipe->getCameraScan(eDir);
	CGrabberControl *pGrabCtrl = pRecipe->getGrabberControl(iCam);
	if (NULL == pGrabCtrl) {
		ClsVision::GenEmptyObject(hImage);
		return false;
	}

	CFrameBufferController *pBuffer = pGrabCtrl->GetFrameBuffer();
	if (nullptr == pBuffer) {
		ClsVision::GenEmptyObject(hImage);
		return false;
	}
	CMultiBuffer *pMultBuffer = pBuffer->GetMultiBuffer();
	if (NULL == pMultBuffer) {
		ClsVision::GenEmptyObject(hImage);
		return false;
	}

	int nFrameWidth = pMultBuffer->GetFrameWidth();
	int nFrameHeight = pMultBuffer->GetFrameHeight();
	int nFrameCount = pMultBuffer->GetFrameCount();
	int nTotalLength = nFrameHeight * nFrameCount;
	if (nTotalLength < 1){
		ClsVision::GenEmptyObject(hImage);
		return false;
	}

	try{
		int imgWidth = nFrameWidth;
		int imgHeight = nTotalLength;
		if (imgHeight > DEFAULTT_IMAGE_HEIGHT) {
			imgHeight = DEFAULTT_IMAGE_HEIGHT;
		}
		if (height > 0) {
			if (imgHeight > height) {
				imgHeight = height;
			}
		}

		//ͼÏñת»»
		uchar *imgData = new uchar[imgWidth * imgHeight];
		BYTE *lpImg = pBuffer->GetMultiBuffData(iScan);
		std::memcpy(imgData, lpImg, imgWidth * imgHeight);
		HalconCpp::GenImage1(&hImage, "byte", imgWidth, imgHeight, (Hlong)(imgData));
		delete[] imgData;
		imgData = NULL;

		return true;
	}
	catch (...)
	{
		ClsVision::GenEmptyObject(hImage);
		return false;
	}
}

bool CVisionBufferPro::getImageROI(DimensionDir eDir, HalconCpp::HObject &hImage, int x1, int y1, int x2, int y2) {
	/* code */
	CVisionRecipe *pRecipe = CVisionRecipe::getInstance();
	int iCam = pRecipe->getCameraIndex(eDir);
	int iScan = pRecipe->getCameraScan(eDir);
	CGrabberControl *pGrabCtrl = pRecipe->getGrabberControl(iCam);
	if (NULL == pGrabCtrl) {
		ClsVision::GenEmptyObject(hImage);
		return false;
	}

	CFrameBufferController *pBuffer = pGrabCtrl->GetFrameBuffer();
	if (nullptr == pBuffer) {
		ClsVision::GenEmptyObject(hImage);
		return false;
	}
	CMultiBuffer *pMultBuffer = pBuffer->GetMultiBuffer();
	if (NULL == pMultBuffer) {
		ClsVision::GenEmptyObject(hImage);
		return false;
	}

	int nFrameWidth = pMultBuffer->GetFrameWidth();
	int nFrameHeight = pMultBuffer->GetFrameHeight();
	int nFrameCount = pMultBuffer->GetFrameCount();
	int nTotalLength = nFrameWidth * nFrameHeight * nFrameCount;
	if (nTotalLength < 1) {
		ClsVision::GenEmptyObject(hImage);
		return false;
	}

	if (x1 < 0 || y1 < 0 || x2 > nFrameWidth - 1 || y2 > nTotalLength - 1) {
		ClsVision::GenEmptyObject(hImage);
		return false;
	}

	try{
		int imgWidth = x2 - x1 + 1;
		int imgHeight = y2 - y1 + 1;
		if (imgWidth < 1 || imgHeight < 1) {
			ClsVision::GenEmptyObject(hImage);
			return false;
		}

		//ͼÏñת»»
		uchar *imgData = new uchar[imgWidth * imgHeight];
		BYTE *lpImg = pBuffer->GetMultiBuffData(iScan);

		for (int i = y1; i <= y2; i++) {
			std::memcpy(imgData + (i - y1) * imgWidth, lpImg + (i * nFrameWidth) + x1, imgWidth);
		}


		HalconCpp::GenImage1(&hImage, "byte", imgWidth, imgHeight, (Hlong)(imgData));
		delete[] imgData;
		imgData = NULL;

		return true;
	}
	catch (...)
	{
		ClsVision::GenEmptyObject(hImage);
		return false;
	}
}

bool CVisionBufferPro::getIndexImage(DimensionDir eDir, HalconCpp::HObject *hImage, int index) {
	/* code */
	CVisionRecipe *pRecipe = CVisionRecipe::getInstance();
	int iCam = pRecipe->getCameraIndex(eDir);
	int iScan = pRecipe->getCameraScan(eDir);
	CGrabberControl *pGrabCtrl = pRecipe->getGrabberControl(iCam);
	if (NULL == pGrabCtrl) {
		HalconCpp::GenEmptyObj(hImage);
		return false;
	}

	CFrameBufferController *pBuffer = pGrabCtrl->GetFrameBuffer();
	if (nullptr == pBuffer) {
		HalconCpp::GenEmptyObj(hImage);
		return false;
	}
	CMultiBuffer *pMultBuffer = pBuffer->GetMultiBuffer();
	if (NULL == pMultBuffer) {
		HalconCpp::GenEmptyObj(hImage);
		return false;
	}
	int nFrameHeight = pMultBuffer->GetFrameHeight();
	int nFrameWidth = pMultBuffer->GetFrameWidth();
	if (nFrameHeight < 1 || nFrameWidth < 1) {
		HalconCpp::GenEmptyObj(hImage);
		return false;
	}

	int x1 = 0;
	int x2 = nFrameWidth - 1;
	int y1 = index * nFrameHeight;
	int y2 = index * nFrameHeight + nFrameHeight - 1;

	return getImageROI(eDir, *hImage, x1, y1, x2, y2);
}

void CVisionBufferPro::getLineFrameSize(DimensionDir eDir, int &nFrameWidth, int &nFrameHeight) {
	/* code */
	// ÉèÖÃÖ¡¿íºÍ¸ß¶ÈΪ-1
	nFrameWidth = -1;
	nFrameHeight = -1;
	// »ñÈ¡CVisionRecipeʵÀý
	CVisionRecipe *pRecipe = CVisionRecipe::getInstance();
	// »ñÈ¡Ö¸¶¨·½ÏòϵÄÏà»úË÷Òý
	int iCam = pRecipe->getCameraIndex(eDir);
	// »ñÈ¡Ö¸¶¨·½ÏòϵÄÏà»úɨÃè·½Ïò
	int iScan = pRecipe->getCameraScan(eDir);
	// »ñÈ¡Ö¸¶¨Ïà»úϵÄCGrabberControlʵÀý
	CGrabberControl *pGrabCtrl = pRecipe->getGrabberControl(iCam);
	// Èç¹ûpGrabCtrlΪ¿Õ£¬Ôò·µ»Ø
	if (NULL == pGrabCtrl) return;

	// »ñÈ¡CFrameBufferControllerʵÀý
	CFrameBufferController *pBuffer = pGrabCtrl->GetFrameBuffer();
	// Èç¹ûpBufferΪ¿Õ£¬Ôò·µ»Ø
	if (nullptr == pBuffer) return;
	// »ñÈ¡CMultiBufferʵÀý
	CMultiBuffer *pMultBuffer = pBuffer->GetMultiBuffer();
	// Èç¹ûpMultBufferΪ¿Õ£¬Ôò·µ»Ø
	if (NULL == pMultBuffer)return;

	// »ñÈ¡Ö¡¸ß¶È
	nFrameHeight = pMultBuffer->GetFrameHeight();
	// »ñÈ¡Ö¡¿í¶È
	nFrameWidth = pMultBuffer->GetFrameWidth();
}

bool CVisionBufferPro::GetMeasurePos(HalconCpp::HObject &hObject, Line2D line, int threshold, int modeTrans, int step, Point2D &ptStart, Point2D &ptEnd) {
	/* code */
	if (!ClsVision::ObjectExist(hObject))  return false;

	try {
		HalconCpp::HTuple LineRowStart_Measure_01_0, LineColumnStart_Measure_01_0, LineRowEnd_Measure_01_0, LineColumnEnd_Measure_01_0;
		LineRowStart_Measure_01_0 = line.pt0.y;
		LineColumnStart_Measure_01_0 = line.pt0.x;
		LineRowEnd_Measure_01_0 = line.pt1.y;
		LineColumnEnd_Measure_01_0 = line.pt1.x;

		HalconCpp::HTuple TmpCtrl_Row, TmpCtrl_Column, TmpCtrl_Dr, TmpCtrl_Dc, TmpCtrl_Phi, TmpCtrl_Len1, TmpCtrl_Len2;
		TmpCtrl_Row = 0.5*(LineRowStart_Measure_01_0 + LineRowEnd_Measure_01_0);
		TmpCtrl_Column = 0.5*(LineColumnStart_Measure_01_0 + LineColumnEnd_Measure_01_0);
		TmpCtrl_Dr = LineRowStart_Measure_01_0 - LineRowEnd_Measure_01_0;
		TmpCtrl_Dc = LineColumnEnd_Measure_01_0 - LineColumnStart_Measure_01_0;

		HalconCpp::TupleAtan2(TmpCtrl_Dr, TmpCtrl_Dc, &TmpCtrl_Phi);

		HalconCpp::TupleSqrt(TmpCtrl_Dr*TmpCtrl_Dr + TmpCtrl_Dc*TmpCtrl_Dc, &TmpCtrl_Len1);
		TmpCtrl_Len1 = 0.5 * TmpCtrl_Len1;
		TmpCtrl_Len2 = 0.5 * step;

		HalconCpp::HTuple hvWidth, hvHeight, MsrHandle_Measure_01_0;
		HalconCpp::GetImageSize(hObject, &hvWidth, &hvHeight);

		HalconCpp::GenMeasureRectangle2(TmpCtrl_Row, TmpCtrl_Column, TmpCtrl_Phi, TmpCtrl_Len1, TmpCtrl_Len2, hvWidth, hvHeight, "nearest_neighbor", &MsrHandle_Measure_01_0);

		HalconCpp::HTuple  Row_Measure_01_0, Column_Measure_01_0, Amplitude_Measure_01_0, Distance_Measure_01_0;
		std::string strMode = "all";
		if (0 == modeTrans) {
			strMode = "all";
		}
		else if (1 == modeTrans) {
			strMode = "positive";
		}
		else if (2 == modeTrans) {
			strMode = "negative";
		}
		HalconCpp::MeasurePos(hObject, MsrHandle_Measure_01_0, 1, threshold, strMode.c_str(), "all", &Row_Measure_01_0, &Column_Measure_01_0, &Amplitude_Measure_01_0, &Distance_Measure_01_0);
		HalconCpp::CloseMeasure(MsrHandle_Measure_01_0);

		bool result = false;
		HalconCpp::HTuple hvLenth;
		HalconCpp::TupleLength(Row_Measure_01_0, &hvLenth);
		int iCount = hvLenth[0].I();
		if (iCount > 0) {
			double dx = abs(line.pt0.x - line.pt1.x);
			bool isInit = false;

			Point2D pt;
			if (dx > 1.0f) {
				for (int i = 0; i < iCount; i++) {
					pt.x = Column_Measure_01_0[i].D();
					pt.y = Row_Measure_01_0[i].D();
					if (!isInit) {
						ptStart.x = Column_Measure_01_0[i].D();
						ptStart.y = Row_Measure_01_0[i].D();
						ptEnd.x = Column_Measure_01_0[i].D();
						ptEnd.y = Row_Measure_01_0[i].D();
						isInit = true;
					}

					result = true;
					if (pt.x < ptStart.x)  ptStart = pt;
					if (pt.x > ptEnd.x)    ptEnd = pt;
				}
			}
			else {
				for (int i = 0; i < iCount; i++) {
					pt.x = Column_Measure_01_0[i].D();
					pt.y = Row_Measure_01_0[i].D();
					if (!isInit) {
						ptStart.x = Column_Measure_01_0[i].D();
						ptStart.y = Row_Measure_01_0[i].D();
						ptEnd.x = Column_Measure_01_0[i].D();
						ptEnd.y = Row_Measure_01_0[i].D();
						isInit = true;
					}

					result = true;
					if (pt.y < ptStart.y)  ptStart = pt;
					if (pt.y > ptEnd.y)    ptEnd = pt;
				}
			}
		}
		return result;
	}
	catch (...)
	{
		return false;
	}
}

bool CVisionBufferPro::GetMeasureNearPos(HalconCpp::HObject& hObject, Line2D line, int threshold, int modeTrans, int step, Point2D& ptStart, Point2D& ptEnd) {
	/* code */
	if (!ClsVision::ObjectExist(hObject))  return false;

	try {
		HalconCpp::HTuple LineRowStart_Measure_01_0, LineColumnStart_Measure_01_0, LineRowEnd_Measure_01_0, LineColumnEnd_Measure_01_0;
		LineRowStart_Measure_01_0 = line.pt0.y;
		LineColumnStart_Measure_01_0 = line.pt0.x;
		LineRowEnd_Measure_01_0 = line.pt1.y;
		LineColumnEnd_Measure_01_0 = line.pt1.x;

		HalconCpp::HTuple TmpCtrl_Row, TmpCtrl_Column, TmpCtrl_Dr, TmpCtrl_Dc, TmpCtrl_Phi, TmpCtrl_Len1, TmpCtrl_Len2;
		TmpCtrl_Row = 0.5 * (LineRowStart_Measure_01_0 + LineRowEnd_Measure_01_0);
		TmpCtrl_Column = 0.5 * (LineColumnStart_Measure_01_0 + LineColumnEnd_Measure_01_0);
		TmpCtrl_Dr = LineRowStart_Measure_01_0 - LineRowEnd_Measure_01_0;
		TmpCtrl_Dc = LineColumnEnd_Measure_01_0 - LineColumnStart_Measure_01_0;

		HalconCpp::TupleAtan2(TmpCtrl_Dr, TmpCtrl_Dc, &TmpCtrl_Phi);

		HalconCpp::TupleSqrt(TmpCtrl_Dr * TmpCtrl_Dr + TmpCtrl_Dc * TmpCtrl_Dc, &TmpCtrl_Len1);
		TmpCtrl_Len1 = 0.5 * TmpCtrl_Len1;
		TmpCtrl_Len2 = 0.5 * step;

		HalconCpp::HTuple hvWidth, hvHeight, MsrHandle_Measure_01_0;
		HalconCpp::GetImageSize(hObject, &hvWidth, &hvHeight);

		HalconCpp::GenMeasureRectangle2(TmpCtrl_Row, TmpCtrl_Column, TmpCtrl_Phi, TmpCtrl_Len1, TmpCtrl_Len2, hvWidth, hvHeight, "nearest_neighbor", &MsrHandle_Measure_01_0);

		HalconCpp::HTuple  Row_Measure_01_0, Column_Measure_01_0, Amplitude_Measure_01_0, Distance_Measure_01_0;
		std::string strMode = "all";
		if (0 == modeTrans) {
			strMode = "all";
		}
		else if (1 == modeTrans) {
			strMode = "positive";
		}
		else if (2 == modeTrans) {
			strMode = "negative";
		}
		HalconCpp::MeasurePos(hObject, MsrHandle_Measure_01_0, 1, threshold, strMode.c_str(), "all", &Row_Measure_01_0, &Column_Measure_01_0, &Amplitude_Measure_01_0, &Distance_Measure_01_0);
		HalconCpp::CloseMeasure(MsrHandle_Measure_01_0);

		bool result = false;
		HalconCpp::HTuple hvLenth;
		HalconCpp::TupleLength(Row_Measure_01_0, &hvLenth);
		int iCount = hvLenth[0].I();
		if (iCount > 0) {
			ptStart.x = Column_Measure_01_0[0].D();
			ptStart.y = Row_Measure_01_0[0].D();

			if (1 == iCount) {
				ptEnd = ptStart;
				return true;
			}

			ptEnd.x = Column_Measure_01_0[1].D();
			ptEnd.y = Row_Measure_01_0[1].D();
			result = true;
		}

		return result;
	}
	catch (...)
	{
		return false;
	}
}

bool CVisionBufferPro::GetMeasureRCutPos(HalconCpp::HObject &hObject, Line2D line, int threshold, int modeTrans, int chamberSize, double proDist, Point2D &ptStart, Point2D &ptEnd) {
	/* code */
	if (!ClsVision::ObjectExist(hObject))  return false;

	try {
		HalconCpp::HTuple LineRowStart_Measure_01_0, LineColumnStart_Measure_01_0, LineRowEnd_Measure_01_0, LineColumnEnd_Measure_01_0;
		LineRowStart_Measure_01_0 = line.pt0.y;
		LineColumnStart_Measure_01_0 = line.pt0.x;
		LineRowEnd_Measure_01_0 = line.pt1.y;
		LineColumnEnd_Measure_01_0 = line.pt1.x;

		HalconCpp::HTuple TmpCtrl_Row, TmpCtrl_Column, TmpCtrl_Dr, TmpCtrl_Dc, TmpCtrl_Phi, TmpCtrl_Len1, TmpCtrl_Len2;
		TmpCtrl_Row = 0.5*(LineRowStart_Measure_01_0 + LineRowEnd_Measure_01_0);
		TmpCtrl_Column = 0.5*(LineColumnStart_Measure_01_0 + LineColumnEnd_Measure_01_0);
		TmpCtrl_Dr = LineRowStart_Measure_01_0 - LineRowEnd_Measure_01_0;
		TmpCtrl_Dc = LineColumnEnd_Measure_01_0 - LineColumnStart_Measure_01_0;

		TmpCtrl_Phi = TmpCtrl_Dr.TupleAtan2(TmpCtrl_Dc);

		HalconCpp::TupleSqrt(TmpCtrl_Dr*TmpCtrl_Dr + TmpCtrl_Dc*TmpCtrl_Dc, &TmpCtrl_Len1);
		TmpCtrl_Len1 = 0.5 * (((TmpCtrl_Dr * TmpCtrl_Dr) + (TmpCtrl_Dc * TmpCtrl_Dc)).TupleSqrt()); 
		TmpCtrl_Len2 = 5.0f;

		HalconCpp::HTuple hvWidth, hvHeight, MsrHandle_Measure_01_0;
		HalconCpp::GetImageSize(hObject, &hvWidth, &hvHeight);

		HalconCpp::GenMeasureRectangle2(TmpCtrl_Row, TmpCtrl_Column, TmpCtrl_Phi, TmpCtrl_Len1, TmpCtrl_Len2, hvWidth, hvHeight, "nearest_neighbor", &MsrHandle_Measure_01_0);

		HalconCpp::HTuple  Row_Measure_01_0, Column_Measure_01_0, Amplitude_Measure_01_0, Distance_Measure_01_0;
		std::string strMode = "all";
		if (0 == modeTrans) {
			strMode = "all";
		}
		else if (1 == modeTrans) {
			strMode = "positive";
		}
		else if (2 == modeTrans) {
			strMode = "negative";
		}
		HalconCpp::MeasurePos(hObject, MsrHandle_Measure_01_0, 1, threshold, strMode.c_str(), "all", 
			&Row_Measure_01_0, &Column_Measure_01_0, &Amplitude_Measure_01_0, &Distance_Measure_01_0);
		HalconCpp::CloseMeasure(MsrHandle_Measure_01_0);

		double fzMinDist = 0.4 * chamberSize;
		if (proDist > 1.0f) {
			double temp = 0.8 * proDist;
			if (temp > fzMinDist) {
				fzMinDist = temp;
			}
		}

		HalconCpp::HTuple hvLenth = Row_Measure_01_0.TupleLength();
		int sz = hvLenth[0].I();
		if (sz < 1) return false;
		if (Amplitude_Measure_01_0[0].D() > 0) return false;
		ptStart.x = Column_Measure_01_0[0].D();
		ptStart.y = Row_Measure_01_0[0].D();

		bool isFind = false;
		double dist = 0.0f; 
		if (sz > 1) {
			for (int i = 1; i < sz; i++) {
				if (Amplitude_Measure_01_0[i].D() < 0.0f) {
					dist += Distance_Measure_01_0[i - 1].D();
					continue;
				}
				ptEnd.x = Column_Measure_01_0[i].D();
				ptEnd.y = Row_Measure_01_0[i].D();
				dist += Distance_Measure_01_0[i - 1].D();
				if (dist > fzMinDist && dist < chamberSize) {
					isFind = true;
					break;
				}

				if (dist > chamberSize) {
					break;
				}
			}
		}

		if ((!isFind) && proDist > 1.0f) {
			dist = ClsVision::DistancePP(ptStart, line.pt1);
			Point2D pose;
			std::vector<Point2D> vPtStd, vPtReal;
			pose.x = 0.0f;
			pose.y = 0.0f;
			vPtStd.push_back(pose);
			pose.x = dist;
			pose.y = 0.0f;
			vPtStd.push_back(pose);
			vPtReal.push_back(ptStart);
			vPtReal.push_back(line.pt1);

			ParaAffine2D affine = ClsVision::VectorToRigid(vPtStd, vPtReal);
			pose.x = proDist;
			pose.y = 0.0f;
			ptEnd = ClsVision::CoordinateTransform(pose, affine);
			isFind = true;
		}

		return isFind;
	}
	catch (...)
	{
		return false;
	}
}

bool CVisionBufferPro::GetMeasurePosKeyLimit(HalconCpp::HObject &hObject, Line2D line, int nTypePoint, int threshold, int modeTrans, int step, int distLimit, Point2D &ptStart, Point2D &ptEnd) {
	/* code */
	if (!ClsVision::ObjectExist(hObject))  return false;

	try {
		HalconCpp::HTuple LineRowStart_Measure_01_0, LineColumnStart_Measure_01_0, LineRowEnd_Measure_01_0, LineColumnEnd_Measure_01_0;
		LineRowStart_Measure_01_0 = line.pt0.y;
		LineColumnStart_Measure_01_0 = line.pt0.x;
		LineRowEnd_Measure_01_0 = line.pt1.y;
		LineColumnEnd_Measure_01_0 = line.pt1.x;

		HalconCpp::HTuple TmpCtrl_Row, TmpCtrl_Column, TmpCtrl_Dr, TmpCtrl_Dc, TmpCtrl_Phi, TmpCtrl_Len1, TmpCtrl_Len2;
		TmpCtrl_Row = 0.5*(LineRowStart_Measure_01_0 + LineRowEnd_Measure_01_0);
		TmpCtrl_Column = 0.5*(LineColumnStart_Measure_01_0 + LineColumnEnd_Measure_01_0);
		TmpCtrl_Dr = LineRowStart_Measure_01_0 - LineRowEnd_Measure_01_0;
		TmpCtrl_Dc = LineColumnEnd_Measure_01_0 - LineColumnStart_Measure_01_0;
		HalconCpp::TupleAtan2(TmpCtrl_Dr, TmpCtrl_Dc, &TmpCtrl_Phi);
		HalconCpp::TupleSqrt(TmpCtrl_Dr*TmpCtrl_Dr + TmpCtrl_Dc*TmpCtrl_Dc, &TmpCtrl_Len1);
		TmpCtrl_Len1 = 0.5 * TmpCtrl_Len1;
		TmpCtrl_Len2 = 0.5 * step;

		HalconCpp::HTuple hvWidth, hvHeight, MsrHandle_Measure_01_0;
		HalconCpp::GetImageSize(hObject, &hvWidth, &hvHeight);

		HalconCpp::GenMeasureRectangle2(TmpCtrl_Row, TmpCtrl_Column, TmpCtrl_Phi, TmpCtrl_Len1, TmpCtrl_Len2, hvWidth, hvHeight, "nearest_neighbor", &MsrHandle_Measure_01_0);

		HalconCpp::HTuple  Row_Measure_01_0, Column_Measure_01_0, Amplitude_Measure_01_0, Distance_Measure_01_0;
		std::string strMode = "all";
		if (0 == modeTrans) {
			strMode = "all";
		}
		else if (1 == modeTrans) {
			strMode = "positive";
		}
		else if (2 == modeTrans) {
			strMode = "negative";
		}
		HalconCpp::MeasurePos(hObject, MsrHandle_Measure_01_0, 1, threshold, strMode.c_str(), "all", &Row_Measure_01_0, &Column_Measure_01_0, &Amplitude_Measure_01_0, &Distance_Measure_01_0);
		HalconCpp::CloseMeasure(MsrHandle_Measure_01_0);

		HalconCpp::HTuple hvLenth;
		HalconCpp::TupleLength(Row_Measure_01_0, &hvLenth);
		int nCount = hvLenth[0].I();
		if (nCount < 1) return false;

		ptStart.x = Column_Measure_01_0[0].D();
		ptStart.y = Row_Measure_01_0[0].D();
		ptEnd.x = Column_Measure_01_0[nCount - 1].D();
		ptEnd.y = Row_Measure_01_0[nCount - 1].D();

		Point2D point;
		if (0 == nTypePoint) {
			point = ptStart;
		}
		else {
			point = ptEnd;
		}

		int idx = -1;
		double maxDist = MININT;
		Point2D pt;
		for (int i = 0; i < nCount; i++) {
			pt.x = Column_Measure_01_0[i].D();
			pt.y = Row_Measure_01_0[i].D();
			double dx = pt.x - point.x;
			double dy = pt.y - point.y;
			double dist = sqrt(dx * dx + dy * dy);
			if (dist < distLimit && dist > maxDist) {
				maxDist = dist;
				idx = i;
			}
		}
		if (idx < 0) return false;

		point.x = Column_Measure_01_0[idx].D();
		point.y = Row_Measure_01_0[idx].D();
		if (0 == nTypePoint) {
			ptStart = point;
		}
		else {
			ptEnd = point;
		}

		return true;
	}
	catch (...)
	{
		return false;
	}
}

bool CVisionBufferPro::getDistResult(DimensionDir eDir, CDistDotProcess *dot, double &result, int &xPosPxl, int &yPosPxl) {
	/* code */
	xPosPxl = 0;
	yPosPxl = 0;
	result = 0.0f;
	CCornerDistProcess *dotCorner = CVisionRecipe::getInstance()->getCornerDistProcess(eDir);
	CBlSideData *pSideData = CVisionRecipe::getInstance()->getSideData(eDir);
	if (NULL == pSideData)  return true;
	if (NULL == dotCorner) return true;
	if (NULL == dot) return true;
	

	Point2D locResult = dot->m_ptMatchResult;
	Point2D measureResult = dot->m_ptMeasureResult;
	Point2D nearResult = dot->m_ptNearResult;

	xPosPxl = dot->m_locPointResult.x;
	yPosPxl = dot->m_locPointResult.y;

	int distMode = dot->m_distMode;
	if (0 == distMode) {
		double dx = measureResult.x - nearResult.x;
		result = fabs(pSideData->m_dPixelSizeX * dx);
	}
	else if (1 == distMode) {
		Point2I topMark = pSideData->getPose(0);
		Point2I botMark = pSideData->getPose(1);

		Line2D line1, line2;
		line1.pt0.x = topMark.x;
		line1.pt0.y = topMark.y;
		line1.pt1.x = botMark.x;
		line1.pt1.y = botMark.y;

		line2.pt0.x = measureResult.x;
		line2.pt0.y = measureResult.y;
		line2.pt1.x = measureResult.x + 1000.0f;
		line2.pt1.y = measureResult.y;

		Point2D pose = ClsVision::LineIntersection(line1, line2);
		double dx = measureResult.x - pose.x;
		result = fabs(pSideData->m_dPixelSizeX * dx);
	}
	else if (2 == distMode) {
		Point2I pose = pSideData->getPose(0);
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		result = sqrt(dx * dx + dy * dy);
	}
	else if (3 == distMode) {
		Point2I pose = pSideData->getPose(1);
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		result = sqrt(dx * dx + dy * dy);
	}
	else if (4 == distMode) {
		Point2I pose = pSideData->getPose(2);
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		result = sqrt(dx * dx + dy * dy);
	}
	else if (5 == distMode) {
		Point2I pose = pSideData->getPose(3);
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		result = sqrt(dx * dx + dy * dy);
	}
	else if (6 == distMode) {
		Point2D pose = nearResult;
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		result = sqrt(dx * dx + dy * dy);
	}
	else if (7 == distMode) {
		Point2D pose = locResult;
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		result = sqrt(dx * dx + dy * dy);
	}

	if (dot->m_maxValue < 0.1) return true;
	if (dot->m_minValue > dot->m_maxValue) return true;

	if (result < dot->m_minValue || result > dot->m_maxValue) return false;

	return true;
}

int CVisionBufferPro::getDistResult(DimensionDir eDir,  CDistDotProcess *dot, double &distResult) {
	/* code */
	//1. ³õʼ»¯½á¹û
	distResult = 0.0f;
	int nRet = 0;
	CCornerDistProcess *dotCorner = CVisionRecipe::getInstance()->getCornerDistProcess(eDir);
	CBlSideData *pSideData = CVisionRecipe::getInstance()->getSideData(eDir);
	if (NULL == pSideData)  return nRet;
	if (NULL == dotCorner) return nRet;
	if (NULL == dot) return nRet;


	Point2D locResult = dot->m_ptMatchResult;
	Point2D measureResult = dot->m_ptMeasureResult;
	Point2D nearResult = dot->m_ptNearResult;

	int distMode = dot->m_distMode;
	if (0 == distMode) {
		double dx = measureResult.x - nearResult.x;
		distResult = fabs(pSideData->m_dPixelSizeX * dx);
	}
	else if (1 == distMode) {
		Point2I topMark = pSideData->getPose(0);
		Point2I botMark = pSideData->getPose(1);

		Line2D line1, line2;
		line1.pt0.x = topMark.x;
		line1.pt0.y = topMark.y;
		line1.pt1.x = botMark.x;
		line1.pt1.y = botMark.y;

		line2.pt0.x = measureResult.x;
		line2.pt0.y = measureResult.y;
		line2.pt1.x = measureResult.x + 1000.0f;
		line2.pt1.y = measureResult.y;

		Point2D pose = ClsVision::LineIntersection(line1, line2);
		double dx = measureResult.x - pose.x;
		distResult = fabs(pSideData->m_dPixelSizeX * dx);
	}
	else if (2 == distMode) {
		Point2I pose = pSideData->getPose(0);
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		distResult = sqrt(dx * dx + dy * dy);
	}
	else if (3 == distMode) {
		Point2I pose = pSideData->getPose(1);
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		distResult = sqrt(dx * dx + dy * dy);
	}
	else if (4 == distMode) {
		Point2I pose = pSideData->getPose(2);
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		distResult = sqrt(dx * dx + dy * dy);
	}
	else if (5 == distMode) {
		Point2I pose = pSideData->getPose(3);
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		distResult = sqrt(dx * dx + dy * dy);
	}
	else if (6 == distMode){
		Point2D pose = nearResult;
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		distResult = sqrt(dx * dx + dy * dy);
	}
	else if (7 == distMode) {
		Point2D pose = locResult;
		double dx = pSideData->m_dPixelSizeX *(measureResult.x - pose.x);
		double dy = pSideData->m_dPixelSizeY *(measureResult.y - pose.y);
		distResult = sqrt(dx * dx + dy * dy);
	}

	if (dot->m_maxValue < 0.1) return 0;
	if (dot->m_minValue > dot->m_maxValue) return 0;

	if (distResult < dot->m_minValue || distResult > dot->m_maxValue) return 1;

	return 0;
}

bool CVisionBufferPro::TransformToReal(DimensionDir eDir, Point2I point, int nType, Point2I &result) {
	/* code */
	result.x = 0;
	result.y = 0;
	CBlSideData *pSideData = CVisionRecipe::getInstance()->getSideData(eDir);
	if (NULL == pSideData) return false;
	if (0 == nType) {
		if (!pSideData->m_bTopMark_Find) return false;
		if (!pSideData->m_bBotMark_Find)  return false;
	}
	else {
		if (!pSideData->m_bTopPoint_Find) return false;
		if (!pSideData->m_bBotPoint_Find) return false;
	}

	double xMmvsp = pSideData->m_dPixelSizeX;
	double yMmvsp = pSideData->m_dPixelSizeY;

	Point2I ptTop, ptBot;
	if (0 == nType) {                    //Origine Mark Line
		ptTop = pSideData->m_mTopMark;
		ptBot = pSideData->m_mBotMark;
	}
	else if (1 == nType) {               //Top MarkPoint
		ptTop = pSideData->m_mTopPoint;
		ptBot = pSideData->m_mBotPoint;
	}
	else if (2 == nType) {               //Bot MarkLine
		ptTop = pSideData->m_mTopPoint;
		ptBot = pSideData->m_mBotPoint;
	}
	double dx = xMmvsp * (ptBot.x - ptTop.x);
	double dy = yMmvsp * (ptBot.y - ptTop.y);
	double dist = sqrt(dx * dx + dy * dy);

	Point2D posTopReal, posBotReal, poseReal;
	posTopReal.x = 0.0f;
	posTopReal.y = 0.0f;
	posBotReal.x = 0.0f;
	posBotReal.y = dist;
	if (0 == nType) {
		poseReal = posTopReal;
		poseReal.x += point.x;
		poseReal.y += point.y;
	}
	else if (1 == nType) {
		poseReal = posTopReal;
		poseReal.x += point.x;
		poseReal.y += point.y;
	}
	else if (2 == nType) {
		poseReal = posBotReal;
		poseReal.x += point.x;
		poseReal.y += point.y;
	}

	std::vector<Point2D> vPtOrigine, vPtReal;
	vPtOrigine.push_back(posTopReal);
	vPtOrigine.push_back(posBotReal);
	Point2D pose;
	pose.x = 0.0f;
	pose.y = 0.0f;
	vPtReal.push_back(pose);
	pose.x = xMmvsp * (ptBot.x - ptTop.x);
	pose.y = yMmvsp * (ptBot.y - ptTop.y);
	vPtReal.push_back(pose);
	ParaAffine2D affine = ClsVision::VectorToSimilarity(vPtOrigine, vPtReal);
	Point2D ptResult = ClsVision::CoordinateTransform(poseReal, affine);
	result.x = (int)(ptTop.x + ptResult.x / xMmvsp);
	result.y = (int)(ptTop.y + ptResult.y / yMmvsp);


#if 0            //Modify, jiang, 09-24, 2024
	Point2D ptImage;
	ptImage.x = point.x;
	ptImage.y = point.y;
	if (1 == nType) {
		std::vector<Point2D> vPtStd, vPtPoint;
		Point2D pt;
		pt.x = pSideData->m_stdTopPoint[0].x;
		pt.y = pSideData->m_stdTopPoint[0].y;
		vPtStd.push_back(pt);
		pt.x = pSideData->m_stdBotPoint[0].x;
		pt.y = pSideData->m_stdBotPoint[0].y;
		vPtStd.push_back(pt);

		pt.x = pSideData->m_mTopPoint.x;
		pt.y = pSideData->m_mTopPoint.y;
		vPtPoint.push_back(pt);
		pt.x = pSideData->m_mBotPoint.x;
		pt.y = pSideData->m_mBotPoint.y;
		vPtPoint.push_back(pt);

		ParaAffine2D affine = ClsVision::VectorToSimilarity(vPtStd, vPtPoint);
		pt = ClsVision::CoordinateTransform(ptImage, affine);
		result.x = (int)(pt.x);
		result.y = (int)(pt.y);
	}
	else if (2 == nType) {
		std::vector<Point2D> vPtStd, vPtPoint;
		Point2D pt;
		pt.x = pSideData->m_stdTopPoint[0].x;
		pt.y = pSideData->m_stdTopPoint[0].y;
		vPtStd.push_back(pt);
		pt.x = pSideData->m_stdTopPoint[1].x;
		pt.y = pSideData->m_stdTopPoint[1].y;
		vPtStd.push_back(pt);

		pt.x = pSideData->m_mTopPoint.x;
		pt.y = pSideData->m_mTopPoint.y;
		vPtPoint.push_back(pt);
		pt.x = pSideData->m_mTopPoint2.x;
		pt.y = pSideData->m_mTopPoint2.y;
		vPtPoint.push_back(pt);

		ParaAffine2D affine = ClsVision::VectorToSimilarity(vPtStd, vPtPoint);
		pt = ClsVision::CoordinateTransform(ptImage, affine);
		result.x = (int)(pt.x);
		result.y = (int)(pt.y);
	}
	else if (3 == nType) {
		std::vector<Point2D> vPtStd, vPtPoint;
		Point2D pt;
		pt.x = pSideData->m_stdBotPoint[0].x;
		pt.y = pSideData->m_stdBotPoint[0].y;
		vPtStd.push_back(pt);
		pt.x = pSideData->m_stdBotPoint[1].x;
		pt.y = pSideData->m_stdBotPoint[1].y;
		vPtStd.push_back(pt);

		pt.x = pSideData->m_mBotPoint.x;
		pt.y = pSideData->m_mBotPoint.y;
		vPtPoint.push_back(pt);
		pt.x = pSideData->m_mBotPoint2.x;
		pt.y = pSideData->m_mBotPoint2.y;
		vPtPoint.push_back(pt);

		ParaAffine2D affine = ClsVision::VectorToSimilarity(vPtStd, vPtPoint);
		pt = ClsVision::CoordinateTransform(ptImage, affine);
		result.x = (int)(pt.x);
		result.y = (int)(pt.y);
	}
#endif

	return true;
}

void CVisionBufferPro::getRect2Point(Point2D rect2CenterPoint, double rect2Phi, double rect2Length1, double rect2Length2, Point2D *rect2Points) {
	/* code */
	double cosValue = cos(rect2Phi);
	double sinValue = sin(rect2Phi);

	double Row = rect2CenterPoint.y;
	double Column = rect2CenterPoint.x;
	double Length1 = rect2Length1;
	double Length2 = rect2Length2;

	//LeftTop Point
	double TopLeft_X = -Length1*cosValue - Length2*sinValue;
	double TopLeft_Y = -Length1*sinValue + Length2*cosValue;
	rect2Points[0].x = Row - TopLeft_Y;
	rect2Points[0].y = Column + TopLeft_X;

	//RightTop Point
	double TopRight_X = Length1*cosValue - Length2*sinValue;
	double TopRight_Y = Length1*sinValue + Length2*cosValue;
	rect2Points[1].x = Row - TopRight_Y;
	rect2Points[1].y = Column + TopRight_X;

	//RightDown Point
	double LowerRight_X = Length1*cosValue + Length2*sinValue;
	double LowerRight_Y = Length1*sinValue - Length2*cosValue;
	rect2Points[2].x = Row - LowerRight_Y;
	rect2Points[2].y = Column + LowerRight_X;

	//LeftDown Point
	double LowerLeft_X = -Length1*cosValue + Length2*sinValue;
	double LowerLeft_Y = -Length1*sinValue - Length2*cosValue;
	rect2Points[3].x = Row - LowerLeft_Y;
	rect2Points[3].y = Column + LowerLeft_X;
}

Line2D CVisionBufferPro::getRect2Line(Point2D rect2CenterPoint, double rect2Phi, int rect2Length2) {
	/* code */
	Point2D rect2Points[4];
	double rect2Length1 = 100.0f;
	double length2 = rect2Length2;
	getRect2Point(rect2CenterPoint, rect2Phi, rect2Length1, length2, rect2Points);
	Line2D line;
	line.pt0.x = 0.5 *(rect2Points[0].x + rect2Points[1].x);
	line.pt0.y = 0.5 *(rect2Points[0].y + rect2Points[1].y);
	line.pt1.x = 0.5 *(rect2Points[2].x + rect2Points[3].x);
	line.pt1.y = 0.5 *(rect2Points[2].y + rect2Points[3].y);
	return line;
}

/////////////////////////////////////////////////////////////////////////////////
void SetMetrologyTransition(int hHandle, int iIndex, int getLineMode){
	/* code */
	if (hHandle < 0 || iIndex < 0) return;

	if (0 == getLineMode){
		HalconCpp::SetMetrologyObjectParam(hHandle, iIndex, "measure_transition", "all");
	}
	else if (1 == getLineMode){
		HalconCpp::SetMetrologyObjectParam(hHandle, iIndex, "measure_transition", "positive");
	}
	else if (2 == getLineMode){
		HalconCpp::SetMetrologyObjectParam(hHandle, iIndex, "measure_transition", "negative");
	}
}

void SetMetrologySelect(int hHandle, int iIndex, int getLineDirection){
	/* code */
	if (hHandle < 0 || iIndex < 0) return;

	if (0 == getLineDirection){
		HalconCpp::SetMetrologyObjectParam(hHandle, iIndex, "measure_select", "all");
	}
	else if (1 == getLineDirection){
		HalconCpp::SetMetrologyObjectParam(hHandle, iIndex, "measure_select", "first");
	}
	else if (2 == getLineDirection){
		HalconCpp::SetMetrologyObjectParam(hHandle, iIndex, "measure_select", "last");
	}
}

bool CVisionBufferPro::LineMeasureByRuler(HalconCpp::HObject &hObject, Line2D line,
	LineMetrologyPara shapeMetrologyPara, Line2D &lineResult)
{
	/* code */
	lineResult = line;
	if (!ClsVision::ObjectExist(hObject)){
		return false;
	}

	try
	{
		//1. ͼÏñ³ß´ç
		int width = 0;
		int height = 0;
		ClsVision::GetImageSize(hObject, width, height);

		//2. ´´½¨²âÁ¿¾ä±ú
		HalconCpp::HTuple hvMetrologyHandle;
		HalconCpp::CreateMetrologyModel(&hvMetrologyHandle);
		HalconCpp::SetMetrologyModelImageSize(hvMetrologyHandle, width, height);

		//3. ´´½¨²âÖ±ÏߵIJÎÊý
		HalconCpp::HTuple hvLineParams;
		if (true){
			Line2D curLine = line;
			int lineDirection = shapeMetrologyPara.direction;
			if (0 == lineDirection){
				if (line.pt0.x < line.pt1.x) {
					curLine = line;
				}
				else {
					curLine.pt1 = line.pt0;
					curLine.pt0 = line.pt1;
				}
			}
			else if (1 == lineDirection){
				if (line.pt0.y < line.pt1.y){
					curLine = line;
				}
				else{
					curLine.pt0 = line.pt1;
					curLine.pt1 = line.pt0;
				}
			}
			//Ö±Ïß·½Ïò
			hvLineParams.Clear();
			hvLineParams.Append(curLine.pt0.y);
			hvLineParams.Append(curLine.pt0.x);
			hvLineParams.Append(curLine.pt1.y);
			hvLineParams.Append(curLine.pt1.x);
		}

		HalconCpp::HTuple hvIndex, hvLen;
		double stepLength = shapeMetrologyPara.stepLength;
		double stepDist = shapeMetrologyPara.stepDist;
		int threshold = shapeMetrologyPara.threshold;
		HalconCpp::AddMetrologyObjectGeneric(hvMetrologyHandle, "line", hvLineParams, stepLength, stepDist, 1, threshold,
			HalconCpp::HTuple(), HalconCpp::HTuple(), &hvIndex);
		int iHandle = hvMetrologyHandle[0].I();

		HalconCpp::TupleLength(hvIndex, &hvLen);
		if (hvLen[0].I() < 1){
			HalconCpp::ClearMetrologyModel(iHandle);
			return false;
		}

		int iIndex = hvIndex[0].I();
		if (iIndex < 0){
			HalconCpp::ClearMetrologyModel(iHandle);
			return false;
		}

		//Ö±Ïߵı߽çµãÀàÐÍ
		int getLineMode = shapeMetrologyPara.getMode;
		SetMetrologyTransition(iHandle, iIndex, getLineMode);

		HalconCpp::SetMetrologyObjectParam(iHandle, iIndex, "num_measures", shapeMetrologyPara.numSample);
		HalconCpp::SetMetrologyObjectParam(iHandle, iIndex, "min_score", shapeMetrologyPara.minScore);

		//ÉèÖÃÖ±ÏßÌáȡģʽ
		SetMetrologySelect(iHandle, iIndex, shapeMetrologyPara.getDirection);
		HalconCpp::ApplyMetrologyModel(hObject, iHandle);
		HalconCpp::HTuple hvParameter, hvLength;
		HalconCpp::GetMetrologyObjectResult(iHandle, iIndex, "all", "result_type", "all_param", &hvParameter);
		HalconCpp::TupleLength(hvParameter, &hvLength);
		if (hvLength[0].I() < 1){
			HalconCpp::ClearMetrologyModel(iHandle);
			return false;
		}

		lineResult.pt0.y = hvParameter[0].D();
		lineResult.pt0.x = hvParameter[1].D();
		lineResult.pt1.y = hvParameter[2].D();
		lineResult.pt1.x = hvParameter[3].D();
		HalconCpp::ClearMetrologyModel(iHandle);

		return true;
	}
	catch (...)
	{
		return false;
	}
}

bool CVisionBufferPro::findCutLine(DimensionDir eDir, Point2I keyPoint, int keyRange, int keyThres, Point2I &result) {
	/* code */
	result.x = 0;
	result.y = 0;
	CBlSideData *pSideData = CVisionRecipe::getInstance()->getSideData(eDir);
	if (NULL == pSideData)  return false;
	if (!pSideData->m_bTopMark_Find)  return false;
	if (!pSideData->m_bBotMark_Find)  return false;

	int x1 = keyPoint.x - keyRange;
	int y1 = keyPoint.y - 31;
	int x2 = keyPoint.x + keyRange;
	int y2 = keyPoint.y + 31;
	Point2I leftTop;
	leftTop.x = x1;
	leftTop.y = y1;
	HalconCpp::HObject hImage;
	if (!getImageROI(eDir, hImage, x1, y1, x2, y2)) return false;

	HalconCpp::HObject hMeanImage;
	HalconCpp::MeanImage(hImage, &hMeanImage, 1, 20);
	int width = 0;
	int height = 0;
	ClsVision::GetImageSize(hImage, width, height);
	if (width < 10 || height < 25)  return false;

	HalconCpp::HObject hLineRegionRoi;
	HalconCpp::GenRegionLine(&hLineRegionRoi, 0.5 * height - 1, 0, 0.5 * height - 1, width - 1);
	HalconCpp::HTuple hvY, hvX, hvGray;
	HalconCpp::GetRegionPoints(hLineRegionRoi, &hvY, &hvX);
	HalconCpp::GetGrayval(hMeanImage, hvY, hvX, &hvGray);
	HalconCpp::HTuple hvLength = hvX.TupleLength();
	int num = hvLength[0].I();
	if (num < 10) return false;

	HalconCpp::HTuple hvCyValue;
	for (int i = 0; i < num; i++) {
		if (hvGray[i].I() < keyThres) {
			hvCyValue[i] = 255;
		}
		else {
			hvCyValue[i] = 0;
		}
	}

	bool isStart = false;
	bool isFind = false;
	int nEdgeLine = 0;
	for (int i = 0; i < num - 1; i++) {
		if (isFind) break;

		if (hvCyValue[i].I() > 120 || hvCyValue[i + 1].I() > 120) {
			isStart = true;
			nEdgeLine = i;
		}

		if (isStart && hvCyValue[i].I() < 120 && hvCyValue[i + 1].I() < 120) {
			isFind = true;
		}
	}
	if (!isFind) return false;

	result.x = leftTop.x + nEdgeLine;
	result.y = leftTop.y + (int)(height / 2);
	return true;
}

int CVisionBufferPro::findNorchDefect(DimensionDir eDir, std::vector<Point2D> vPoints, CRect roiRect, int nThres, int nOffset, int nBinThres, 
	int szType, int xFzSize, int yFzSize, CRect* aryResult) {
	/* code */
	if (roiRect.Width() < 10 || roiRect.Height() < 10) return 0;
	if (nThres < 5 || nBinThres < 5) return 0;
	if (0 == szType)  return 0;

	int sz = (int)(vPoints.size());
	if (sz < 3) return 0;

	std::vector<Point2D> vEdgePoints;
	for (auto item : vPoints) {
		Point2D point = item;
		vEdgePoints.push_back(point);
	}
	//1. ½øÐÐ×ÔÉ϶øϵÄÅÅÐò
	for (int i = 0; i < sz - 1; i++) {
		for (int j = i + 1; j < sz; j++) {
			if (vEdgePoints[i].y > vEdgePoints[j].y) {
                Point2D temp = vEdgePoints[i];
				vEdgePoints[i] = vEdgePoints[j];
				vEdgePoints[j] = temp;
			}
		}
	}

	//2. ½ØÈ¡ROIͼÏñ
	int x1 = roiRect.left;
	int y1 = roiRect.top;
	int x2 = roiRect.right;
	int y2 = roiRect.bottom;
	HalconCpp::HObject hImage;
	if (!getImageROI(eDir, hImage, x1, y1, x2, y2)) return 0;

	int width = 0;
	int height = 0;
	ClsVision::GetImageSize(hImage, width, height);
	if (width < 10 || height < 10) return 0;


	//3. µãλƫÒÆ
	for (int i = 0; i < sz; i++) {
		vEdgePoints[i].x -= roiRect.left;
        vEdgePoints[i].y -= roiRect.top;
	}

	int edgeThres = nThres;
	if (nThres > 10) {
		edgeThres = 10;
	}

	std::vector<vec> vEdgeCtrlPoint;
	for (int i = 0; i < sz; i++) {
		if (0 != i) {
			double dy = vEdgePoints[i].y - vEdgePoints[i - 1].y;
			double dx = vEdgePoints[i].x - vEdgePoints[i - 1].x;
			if (dy > 450) {
				for (int j = 0; j < 3; j++) {
					Line2D line;
					line.pt0.x = vEdgePoints[i - 1].x + (j + 1) * dx / 4 - 75;
					line.pt0.y = vEdgePoints[i - 1].y + (j + 1) * dy / 4;
					line.pt1.x = vEdgePoints[i - 1].x + (j + 1) * dx / 4 + 75;
					line.pt1.y = vEdgePoints[i - 1].y + (j + 1) * dy / 4;
					if (line.pt0.x < 0) line.pt0.x = 1;
					if (line.pt0.x > width - 1) line.pt0.x = width - 2;
					if (line.pt0.y < 0) line.pt0.y = 1;
					if (line.pt0.y > height - 1) line.pt0.y = height - 2;
					if (line.pt1.x < 0) line.pt1.x = 1;
					if (line.pt1.x > width - 1) line.pt1.x = width - 2;
					if (line.pt1.y < 0) line.pt1.y = 1;
					if (line.pt1.y > height - 1) line.pt1.y = height - 2;
					if (line.pt1.x > line.pt0.x) {
						Point2D ptStart, ptEnd;
						if (CVisionBufferPro::GetMeasureNearPos(hImage, line, edgeThres, 0, 10, ptStart, ptEnd)) {
							float xPos = (float)(ptEnd.x);
							float yPos = (float)(ptEnd.y);
							vec p1(xPos, yPos, 0);
							vEdgeCtrlPoint.push_back(p1);
						}
					}
				}
			}
			else if (dy > 300) {
				for (int j = 0; j < 2; j++) {
					Line2D line;
					line.pt0.x = vEdgePoints[i - 1].x + (j + 1) * dx / 3 - 75;
					line.pt0.y = vEdgePoints[i - 1].y + (j + 1) * dy / 3;
					line.pt1.x = vEdgePoints[i - 1].x + (j + 1) * dx / 3 + 75;
					line.pt1.y = vEdgePoints[i - 1].y + (j + 1) * dy / 3;
					if (line.pt0.x < 0) line.pt0.x = 1;
					if (line.pt0.x > width - 1) line.pt0.x = width - 2;
					if (line.pt0.y < 0) line.pt0.y = 1;
					if (line.pt0.y > height - 1) line.pt0.y = height - 2;
					if (line.pt1.x < 0) line.pt1.x = 1;
					if (line.pt1.x > width - 1) line.pt1.x = width - 2;
					if (line.pt1.y < 0) line.pt1.y = 1;
					if (line.pt1.y > height - 1) line.pt1.y = height - 2;
					if (line.pt1.x > line.pt0.x) {
						Point2D ptStart, ptEnd;
						if (CVisionBufferPro::GetMeasureNearPos(hImage, line, edgeThres, 0, 10, ptStart, ptEnd)) {
							float xPos = (float)(ptEnd.x);
							float yPos = (float)(ptEnd.y);
							vec p1(xPos, yPos, 0);
							vEdgeCtrlPoint.push_back(p1);
						}
					}
				}
			}
			else {
				Line2D line;
				line.pt0.x = 0.5 * (vEdgePoints[i].x + vEdgePoints[i - 1].x) - 75;
				line.pt0.y = 0.5 * (vEdgePoints[i].y + vEdgePoints[i - 1].y);
				line.pt1.x = 0.5 * (vEdgePoints[i].x + vEdgePoints[i - 1].x) + 75;
				line.pt1.y = 0.5 * (vEdgePoints[i].y + vEdgePoints[i - 1].y);
				if (line.pt0.x < 0) line.pt0.x = 1;
				if (line.pt0.x > width - 1) line.pt0.x = width - 2;
				if (line.pt0.y < 0) line.pt0.y = 1;
				if (line.pt0.y > height - 1) line.pt0.y = height - 2;
				if (line.pt1.x < 0) line.pt1.x = 1;
				if (line.pt1.x > width - 1) line.pt1.x = width - 2;
				if (line.pt1.y < 0) line.pt1.y = 1;
				if (line.pt1.y > height - 1) line.pt1.y = height - 2;
				if (line.pt1.x > line.pt0.x) {
					Point2D ptStart, ptEnd;
					if (CVisionBufferPro::GetMeasureNearPos(hImage, line, edgeThres, 0, 10, ptStart, ptEnd)) {
						float xPos = (float)(ptEnd.x);
						float yPos = (float)(ptEnd.y);
						vec p1(xPos, yPos, 0);
						vEdgeCtrlPoint.push_back(p1);
					}
				}
			}
		}
		Point2D point = vEdgePoints[i];
		vec p0((float)point.x, (float)point.y, 0);
		vEdgeCtrlPoint.push_back(p0);
	}

	CBspline bspline(vEdgeCtrlPoint);
	bspline.execute();

	int number = (int)(bspline.m_vPtResults.size());
	if (number < 10) return 0;

	std::vector<Point2D> vPointResults;
	for (int i = 0; i < number; i++) {
		Point2D point;
		point.x = bspline.m_vPtResults[i][0] + nOffset;
        point.y = bspline.m_vPtResults[i][1];
        vPointResults.push_back(point);
	}

	HalconCpp::HTuple hvY, hvX;
	int idx = 0;
	for (auto item : vPointResults) {
		hvX[idx] = item.x;
		hvY[idx] = item.y;
		idx += 1;
	}

	hvX[idx] = width - 5;
	hvY[idx] = height - 5;
	idx += 1;

	hvX[idx] = width - 5;
	hvY[idx] = 5;
	idx += 1;

	HalconCpp::HObject hRoiRegion;
	HalconCpp::GenRegionPolygonFilled(&hRoiRegion, hvY, hvX);

#if 0
	HalconCpp::HWindow hDispWin(0, 0, 0.4 * width, 0.4 * height);
	hDispWin.SetPart(0, 0, height-1, width-1);
	hDispWin.SetColor("green");
	hDispWin.SetDraw("margin");
	hDispWin.DispObj(hImage);
	hDispWin.DispObj(hRoiRegion);
	hDispWin.Click();
#endif

	HalconCpp::HObject hBinRegion, hRegion, hConnectRegion, hSelectRegion;
	HalconCpp::ReduceDomain(hImage, hRoiRegion, &hBinRegion);
	HalconCpp::Threshold(hBinRegion, &hRegion, 0, nBinThres);
	HalconCpp::Connection(hRegion, &hConnectRegion);
	if (1 == szType) {
		HalconCpp::HObject hSelectRegionX, hSelectRegionY, hConcatRegion, hUinonRegion, hClosngRegion;
		HalconCpp::SelectShape(hConnectRegion, &hSelectRegionX, "width", "and", xFzSize, 99999999);
		HalconCpp::SelectShape(hConnectRegion, &hSelectRegionY, "height", "and", yFzSize, 99999999);
		HalconCpp::ConcatObj(hSelectRegionX, hSelectRegionY, &hConcatRegion);
		HalconCpp::Union1(hConcatRegion, &hUinonRegion);
		HalconCpp::ClosingCircle(hUinonRegion, &hClosngRegion, 7.5);
		HalconCpp::Connection(hClosngRegion, &hSelectRegion);
	}
	else {
		HalconCpp::HObject hSelectRegionX, hSelectRegionY, hConcatRegion, hUinonRegion, hClosngRegion;
		HalconCpp::SelectShape(hConnectRegion, &hSelectRegionX, "width", "and", xFzSize, 99999999);
		HalconCpp::SelectShape(hSelectRegionX, &hSelectRegion, "height", "and", yFzSize, 99999999);
		HalconCpp::Union1(hSelectRegion, &hUinonRegion);
		HalconCpp::ClosingCircle(hUinonRegion, &hClosngRegion, 7.5);
		hSelectRegion.Clear();
		HalconCpp::Connection(hClosngRegion, &hSelectRegion);
	}
#if 0
	hDispWin.SetColored(6);
	hDispWin.SetDraw("fill");
	hDispWin.DispObj(hSelectRegion);
	hDispWin.Click();
#endif
	int nRet = ClsVision::ObjectNumber(hSelectRegion);
	if (nRet < 1) return 0;

	HalconCpp::HTuple hvY1, hvX1, hvY2, hvX2;
	HalconCpp::SmallestRectangle1(hSelectRegion, &hvY1, &hvX1, &hvY2, &hvX2);
	int nNumber = 0;
	for (int i = 0; i < nRet; i++) {
		aryResult[i].left = hvX1[i].I() + roiRect.left;
		aryResult[i].top = hvY1[i].I() + roiRect.top;
		aryResult[i].right = hvX2[i].I() + roiRect.left;
		aryResult[i].bottom = hvY2[i].I() + roiRect.top;
		nNumber += 1;
		if (i > 99) break;
	}

	return nNumber;
}