#include "eyemMisc.h"

static void drawLine(cv::InputOutputArray img, cv::Point pt1, cv::Point pt2, const cv::Scalar& color, int thickness, double tipLength, double trackLength, std::vector<cv::Point> &trackLine)
{
	const double angle = atan2((double)pt1.y - pt2.y, (double)pt1.x - pt2.x);

	cv::Point p(cvRound(pt2.x + tipLength * cos(angle + CV_PI / 2)),
		cvRound(pt2.y + tipLength * sin(angle + CV_PI / 2)));
	//cv::arrowedLine(img, pt2, p, cv::Scalar(0, 0, 255, 255), 1, 8, 0, 0.4);

	p.x = cvRound(pt2.x + tipLength * cos(angle - CV_PI / 2));
	p.y = cvRound(pt2.y + tipLength * sin(angle - CV_PI / 2));
	//cv::arrowedLine(img, pt2, p, cv::Scalar(0, 0, 255, 255), 1, 8, 0, 0.4);

	p = cv::Point(cvRound(pt2.x + tipLength * cos(angle)),
		cvRound(pt2.y + tipLength * sin(angle)));
	//cv::arrowedLine(img, pt2, p, color, 1, 8, 0, 0.3);
	//位置
	p = cv::Point(cvRound(pt2.x + trackLength * cos(angle)),
		cvRound(pt2.y + trackLength * sin(angle)));
	trackLine.push_back(p);

	p = cv::Point(cvRound(pt2.x + tipLength * cos(angle + CV_PI)),
		cvRound(pt2.y + tipLength * sin(angle + CV_PI)));
	//cv::arrowedLine(img, pt2, p, color, 1, 8, 0, 0.3);
	//位置
	p = cv::Point(cvRound(pt2.x + trackLength * cos(angle + CV_PI)),
		cvRound(pt2.y + trackLength * sin(angle + CV_PI)));
	trackLine.push_back(p);
}

static inline bool isInRect(std::vector<cv::Point2f> _Rect, cv::Point pt)
{
	return cv::pointPolygonTest(_Rect, pt, false) > 0;
}

static void calcRotateRect(std::vector<cv::Point2f> &vRect, std::vector<cv::Point> &vPoints)
{
	cv::Rect _Rect = cv::RotatedRect(vRect[0], vRect[1], vRect[2]).boundingRect();
	for (int y = _Rect.y; y < _Rect.y + _Rect.height; y++)
	{
		for (int x = _Rect.x; x < _Rect.x + _Rect.width; x++)
		{
			if (isInRect(vRect, cv::Point(x, y)))
			{
				vPoints.push_back(cv::Point(x, y));
			}
		}
	}
}

static int Otsu(int hist[])
{
	// Otsu's threshold algorithm
	// C++ code by Jordan Bevik <Jordan.Bevic@qtiworld.com>
	// ported to ImageJ plugin by G.Landini
	int k, kStar;  // k = the current threshold; kStar = optimal threshold
	double N1, N;    // N1 = # points with intensity <=k; N = total number of points
	double BCV, BCVmax; // The current Between Class Variance and maximum BCV
	double num, denom;  // temporary bookeeping
	double Sk;  // The total intensity for all histogram points <=k
	double S, L = 256; // The total intensity of the image

					   // Initialize values:
	S = N = 0;
	for (k = 0; k < L; k++) {
		S += (double)k * hist[k];	// Total histogram intensity
		N += hist[k];		// Total number of data points
	}

	Sk = 0;
	N1 = hist[0]; // The entry for zero intensity
	BCV = 0;
	BCVmax = 0;
	kStar = 0;

	// Look at each possible threshold value,
	// calculate the between-class variance, and decide if it's a max
	for (k = 1; k < L - 1; k++) { // No need to check endpoints k = 0 or k = L-1
		Sk += (double)k * hist[k];
		N1 += hist[k];

		// The float casting here is to avoid compiler warning about loss of precision and
		// will prevent overflow in the case of large saturated images
		denom = (double)(N1) * (N - N1); // Maximum value of denom is (N^2)/4 =  approx. 3E10

		if (denom != 0) {
			// Float here is to avoid loss of precision when dividing
			num = ((double)N1 / N) * S - Sk; 	// Maximum value of num =  255*N = approx 8E7
			BCV = (num * num) / denom;
		}
		else
			BCV = 0;

		if (BCV >= BCVmax) { // Assign the best threshold found so far
			BCVmax = BCV;
			kStar = k;
		}
	}
	return kStar;
}

static bool checkSize(cv::Mat &srcPrev, cv::Mat &mask, int &partSize)
{
	int X = srcPrev.cols, Y = srcPrev.rows;
	//for fill backgrounds where the reel is not obvious, the component is not split when the OTSU threshold is selected
	cv::morphologyEx(mask, mask, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(75, 75)));
	//calculate the histogram
	int hist[256];
	for (int y = 0; y < 256; y++) hist[y] = 0;
	for (int y = 0; y < Y; y++)
	{
		uchar *uPtr = srcPrev.data + y * X;
		for (int x = 0; x < srcPrev.cols; x++, uPtr++)
		{
			if ((mask.data)[(x)+(y)*X] == 255)
			{
				hist[*uPtr]++;
			}
		}
	}
	int meanThresh = Otsu(hist);
	cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range range)->void {
		for (int y = range.start; y < range.end; y++)
		{
			for (int x = 0; x < X; x++)
			{
				if ((srcPrev.data)[(x)+(y)*X] <= meanThresh)
				{
					(srcPrev.data)[(x)+(y)*X] = meanThresh;
				}
			}
		}
	});
	cv::Mat binary;
	cv::threshold(srcPrev, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
	//connectivity analysis
	cv::Mat m1, m2, m3;
	int nccomps = cv::connectedComponentsWithStats(binary, m1, m2, m3);
	std::vector<uchar> colors(nccomps + 1, 0);
	for (int i = 1; i < nccomps; i++) {
		colors[i] = 255;
		if ((((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] <= 3))//experience
		{
			colors[i] = 0;
		}
	}
	//think it's sticky
	cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
		for (int y = range.start; y < range.end; y++)
		{
			for (int x = 0; x < X; x++)
			{
				int label = ((int *)m1.data)[(x)+(y)*m1.cols];
				CV_Assert(0 <= label && label <= nccomps);
				(binary.data)[(x)+(y)*X] = colors[label];
			}
		}
	});
	nccomps = cv::connectedComponentsWithStats(binary, m1, m2, m3);
	//
	if (nccomps <= 1) return false;
	//area of the statistical component
	std::vector<int> vHist(nccomps);
	for (int y = 0; y < Y; y++)
	{
		int *uPtr = (int *)m1.data + y * X;
		for (int x = 0; x < X; x++, uPtr++)
		{
			vHist[*uPtr]++;
		}
	}
	std::map<int, int> cAreaMap;
	for (const auto& v : vHist)
	{
		std::map<int, int>::iterator it = cAreaMap.find(v);
		if (it != cAreaMap.end())
		{
			it->second++;
			continue;
		}
		else { cAreaMap.insert(std::make_pair(v, 1)); };
	}
	struct tMap
	{
		int Key;
		int Value;
		tMap(int Key, int Value) :Key(Key), Value(Value) {}

		bool operator >(const tMap &te)const
		{
			return Value > te.Value;
		}
	};
	//get a single component area (accuracy to be tested, assuming non-adhesion accounts for the majority).)
	std::vector<tMap> tVector;
	std::map<int, int>::iterator it;
	for (it = cAreaMap.begin(); it != cAreaMap.end(); it++)
	{
		tVector.push_back(tMap(it->first, it->second));
	}
	std::sort(tVector.begin(), tVector.end(), std::greater<tMap>());
	if (tVector.size() < 3)
	{
		return false;
	}
	mask = binary.clone();
	//single component
	partSize = cvRound((tVector[0].Key + tVector[1].Key) / 2.);
	return  partSize >= 20;
}

int eyemCountObject(EyemImage tpImage, const char *fileName, double dOffset, int iMinArea, int iMaxArea, int iWinSize, LPSTR *lpszNumObj, EyemImage *tpDstImg)
{
	cv::Mat src = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage);
	if (src.empty()) {
		return FUNC_IMAGE_NOT_EXIST;
	}
	//转单通道
	if (src.channels() != 1)
		cv::cvtColor(src, src, cv::COLOR_BGR2GRAY);

	cv::Mat src8U;
	//环鸿&佳世达
	src = src(cv::Range(200, src.cols - 70), cv::Range(200, src.rows - 10)).clone();
	//苏州公司
	//src = src(cv::Range(10, src.cols - 10), cv::Range(10, src.rows - 10)).clone();
	//image size
	int X = src.cols, Y = src.rows;
	//special for suzhou 
#define SUZHOU true
#if SUZHOU
	cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range range)->void {
		for (int y = range.start; y < range.end; y++)
		{
			for (int x = 0; x < X; x++)
			{
				//苏州公司7100/佳世达4800
				if (((short *)src.data)[(x)+(y)*X] >= 4800)
				{
					((short *)src.data)[(x)+(y)*X] = 4800;
				}
			}
		}
	});
#endif
	//image enhancement
	double min, max;
	cv::Point maxId;
	cv::minMaxLoc(src, &min, &max, NULL, &maxId);
	src.convertTo(src, CV_64FC1);

	src -= min;
	src /= (max - min);
	src *= 65535;
	src.convertTo(src, CV_16UC1);
	src.convertTo(src8U, CV_8UC1, 1 / 255.);
	//for show
	cv::Mat cc;
	cv::cvtColor(src8U, cc, cv::COLOR_GRAY2BGRA);
	//set bins
	const int histSize = 17;
	//range of values
	float range[] = { 0,255 };
	const float* histRange = { range };
	//calculate the histogram
	cv::Mat hist;
	cv::calcHist(&src8U, 1, 0, cv::Mat(), hist, 1, &histSize, &histRange);
	//calculate the background pixels
	int maxIdx[2] = { 255,255 };
	cv::minMaxIdx(hist, NULL, NULL, NULL, maxIdx);
	//background thresh
	int backThresh = 15 * (maxIdx[0] - 2);//正常-2
	//remove the background
	cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range range)->void {
		for (int y = range.start; y < range.end; y++)
		{
			for (int x = 0; x < X; x++)
			{
				if ((src8U.data)[(x)+(y)*X] >= backThresh)
				{
					(src8U.data)[(x)+(y)*X] = backThresh;
				}
			}
		}
	});
	//increases to target brightness
	cc += cv::Scalar((162 - backThresh), (162 - backThresh), (162 - backThresh));
	//inv
	cv::bitwise_not(src8U, src8U);
	cv::Mat binary;
	cv::threshold(src8U, binary, (255 - backThresh), 255, cv::THRESH_BINARY);
	//connected together
	cv::morphologyEx(binary, binary, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(45, 45)));
	//find the pallet
	std::vector<std::vector<cv::Point>> contoursFilter;
	cv::findContours(binary, contoursFilter, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
	//填充内部确定料盘
	cv::Mat image = cv::Mat::zeros(src8U.size(), CV_8UC1);
	for (int i = 0; i < contoursFilter.size(); i++)
	{
		if (cv::contourArea(contoursFilter[i]) > 100000)
		{
			cv::drawContours(image, contoursFilter, i, cv::Scalar(255), -1);
		}
	}
	cv::bitwise_not(src8U, src8U);
	//剩下即料盘区域（面积大于100000均认为是料盘）
	cv::findContours(image, contoursFilter, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
	//区分多个料盘
	struct TrayPos
	{
		int iDir = -1;//0左上1左下2右下3右上
		double dBackThresh;
		bool bSorted;
		cv::Point2f Center;
		cv::Mat Tray;
		TrayPos() {};
		TrayPos(cv::Point2f center, cv::Mat tray, bool bSorted, double dBackThresh) :Center(center), Tray(tray), bSorted(bSorted), dBackThresh(dBackThresh) {}
	};
	std::vector <TrayPos> trays;
	for (int i = 0; i < contoursFilter.size(); i++)
	{
		//定位中心
		cv::Moments mu = cv::moments(contoursFilter[i]);
		cv::Point reelCenter(cvRound(mu.m10 / mu.m00), cvRound(mu.m01 / mu.m00));
		//掩膜
		cv::Mat trayMask = cv::Mat::zeros(Y, X, CV_8UC1);
		cv::drawContours(trayMask, contoursFilter, i, cv::Scalar(255), -1);
		//
		cv::Mat tray = cv::Mat(Y, X, CV_8UC1, backThresh);
		src8U.copyTo(tray, trayMask);
		trays.push_back(TrayPos(reelCenter, tray, false, backThresh));
	}
	//判断可能无料，不能100%判断
	if (trays.size() < 1)
	{
		std::string strTrayNum = "无料,";
		*lpszNumObj = (char *)CoTaskMemAlloc(strTrayNum.size());
		if (NULL != *lpszNumObj)
		{
			strcpy(*lpszNumObj, strTrayNum.c_str());
		}
		return FUNC_CANNOT_CALC;
	}
	//图像中心
	cv::Point reelCenter(X / 2, Y / 2);
	//料盘排序
	std::vector <TrayPos> sortedTrays;
	for (int i = 0; i < trays.size(); i++)
	{
		//左上角
		if (trays[i].Center.x < reelCenter.x&&trays[i].Center.y < reelCenter.y)
		{
			if (trays[i].bSorted == false)
			{
				trays[i].iDir = 0;
				trays[i].bSorted = true;
				sortedTrays.push_back(trays[i]);
			}
		}
	}
	for (int i = 0; i < trays.size(); i++)
	{
		//左下角
		if (trays[i].Center.x < reelCenter.x&&trays[i].Center.y > reelCenter.y)
		{
			if (trays[i].bSorted == false)
			{
				trays[i].iDir = 1;
				trays[i].bSorted = true;
				sortedTrays.push_back(trays[i]);
			}
		}
	}
	for (int i = 0; i < trays.size(); i++)
	{
		//右下角
		if (trays[i].Center.x > reelCenter.x&&trays[i].Center.y > reelCenter.y)
		{
			if (trays[i].bSorted == false)
			{
				trays[i].iDir = 2;
				trays[i].bSorted = true;
				sortedTrays.push_back(trays[i]);
			}
		}
	}
	for (int i = 0; i < trays.size(); i++)
	{
		//右上角
		if (trays[i].Center.x > reelCenter.x&&trays[i].Center.y < reelCenter.y)
		{
			if (trays[i].bSorted == false)
			{
				trays[i].iDir = 3;
				trays[i].bSorted = true;
				sortedTrays.push_back(trays[i]);
			}
		}
	}
	//计数
	std::vector<int> trayNum(4);
	const char icvCodeDeltas[3][3][2] = { { { 0, -1 },{ 1, -1 },{ 1, 0 } },{ { 1, 1 },{ 0,  1 },{ -1,  1 } },{ { -1,  0 },{ -1,  -1 },{ 0,  -1 } } };
	//分料盘计数
	for (int i = 0; i < sortedTrays.size(); i++)
	{
		cv::Mat srcPrev;
		cv::bitwise_not(sortedTrays[i].Tray, srcPrev);
		//二值化可以分别放在两个算法里
		cv::Mat sinParts;
		cv::threshold(srcPrev, sinParts, (255 - sortedTrays[i].dBackThresh), 255, cv::THRESH_BINARY);
		//判断元件尺寸
		int sinPartSize;
		bool useTrackMethod = checkSize(srcPrev, sinParts, sinPartSize);
		//判断大小
		cv::Mat m1, m2, m3;
		int nccomps = cv::connectedComponentsWithStats(sinParts, m1, m2, m3);
		//判断适用哪种算法
		if (!useTrackMethod)
		{
			const int filterSize = 12;
			//去掉料盘深色部分干扰
			const int winSize = sinPartSize > 15 ? 5 : 3;//对于部分器件过小的窗口会漏料
			cv::Mat srcPrevEx;
			cv::morphologyEx(srcPrev, srcPrevEx, cv::MORPH_TOPHAT, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(winSize, winSize)));
			//二值化元件区域,用OTSU还是其他？
			cv::Mat sinPartMask;
			cv::threshold(srcPrevEx, sinPartMask, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
			//连在一起
			cv::morphologyEx(sinPartMask, srcPrevEx, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(5, 5)));
			//去除孔洞
			cv::morphologyEx(srcPrevEx, srcPrevEx, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(21, 21)));
			//去除深色部分备份
			cv::Mat removeDark = srcPrevEx.clone();
			//最大外包
			cv::morphologyEx(srcPrevEx, srcPrevEx, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(45, 45)));
			//定位料盘中心
			cv::findContours(srcPrevEx, contoursFilter, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
			image = cv::Scalar(0);
			for (int i = 0; i < contoursFilter.size(); i++)
			{
				cv::drawContours(image, contoursFilter, i, cv::Scalar(255), -1);
			}
			image -= srcPrevEx;
			//获取最大轮廓
			cv::findContours(image, contoursFilter, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
			if (contoursFilter.size() <= 0)
			{
				continue;
			}
			std::vector<cv::Point> contourMax = contoursFilter[0];
			for (int i = 1; i < contoursFilter.size(); i++)
			{
				if (cv::contourArea(contoursFilter[i]) > cv::contourArea(contourMax))
				{
					contourMax = contoursFilter[i];
				}
			}
			cv::Moments mu = cv::moments(contourMax);
			cv::Point2f reelCenter(float(mu.m10 / mu.m00), float(mu.m01 / mu.m00));
			//画中心
			//计算最大外接圆半径
			float tFRadius = 0;
			cv::minEnclosingCircle(contourMax, cv::Point2f(), tFRadius);
			reelCenter.x = reelCenter.x > 0 && reelCenter.x < X ? reelCenter.x : 0;
			reelCenter.y = reelCenter.y > 0 && reelCenter.y < Y ? reelCenter.y : 0;
			cv::drawMarker(cc, reelCenter, cv::Scalar(0, 0, 238, 255), 1, 35, 2);
			//去掉中心1/3区域
			cv::circle(sinPartMask, reelCenter, cvRound(tFRadius / 2), cv::Scalar(0), -1);
			//掩膜区域,用于区分处理区域
			uchar *upMask = sinPartMask.data;
			//最小料不进行粘连判断
			cv::Mat mulParts(Y, X, CV_8UC1, cv::Scalar(0));
			//
			std::vector<uchar> colors(nccomps + 1, 0);
			if (sinPartSize >= filterSize)
			{
				upMask = mulParts.data;
				//根据元件大小确定是否进行粘连处理
				for (int i = 1; i < nccomps; i++) {
					colors[i] = 0;
					if (((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] >= 1.6*sinPartSize)//经验值
					{
						colors[i] = 255;
					}
				}
				//认为是粘连
				cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
					for (int y = range.start; y < range.end; y++)
					{
						for (int x = 0; x < X; x++)
						{
							int label = ((int *)m1.data)[(x)+(y)*m1.cols];
							CV_Assert(0 <= label && label <= nccomps);
							(mulParts.data)[(x)+(y)*X] = colors[label];
						}
					}
				});
				sinParts &= removeDark;
				mulParts &= removeDark;
				sinParts -= mulParts;
				cv::circle(sinParts, reelCenter, cvRound(tFRadius / 2), cv::Scalar(0), -1);
				cv::circle(mulParts, reelCenter, cvRound(tFRadius / 2), cv::Scalar(0), -1);
			}
			//标签图像
			unsigned char *pLabelImg = (unsigned char *)malloc(Y*X * sizeof(unsigned char));
			memset(pLabelImg, 0, X*Y * sizeof(unsigned char));
			cv::Mat lbImage(Y, X, CV_8UC1, pLabelImg);
			//区分不同大小器件用不同的图处理
#define upSrc(x, y) (srcPrev.data)[(x) + (y)*X]
			//连通域非极大值处理
			for (int y = 1; y < Y - 1; y++)
			{
				for (int x = 1; x < X - 1; x++)
				{
					//属于连通域内，并且尚未被标记
					if (upMask[(x)+(y)*X] != 0 && pLabelImg[(x)+(y)*X] != 255)
					{
						//生长种子点
						auto pixval = upSrc(x, y);
						if (pixval >= upSrc((x - 1), (y - 1)) && pixval >= upSrc((x), (y - 1)) && pixval >= upSrc((x + 1), (y - 1))\
							&& pixval >= upSrc((x + 1), (y)) && pixval >= upSrc((x + 1), (y + 1)) && pixval >= upSrc((x), (y + 1))\
							&& pixval >= upSrc((x - 1), (y + 1)) && pixval >= upSrc((x - 1), (y)))
						{
							//标记已处理
							pLabelImg[(x)+(y)*X] = 255;
							unsigned char direction = 0;
							unsigned int xx = x;
							unsigned int yy = y;
							bool growEnd = false;
							do
							{
								for (unsigned int n = 0; n < 3; n++)
								{
									bool found = false;
									for (unsigned char i = 0; i < 3; i++)
									{
										int nx = xx + icvCodeDeltas[direction][i][0];
										int ny = yy + icvCodeDeltas[direction][i][1];
										//越界处理
										if (nx < 2 || ny < 2 || nx>srcPrev.cols - 2 || ny>srcPrev.rows - 2)
											continue;

										//考虑多加个条件限制峰值
										auto val = upSrc((nx), (ny));
										if (val >= pixval&&pLabelImg[(nx)+(ny)*X] != 255)
										{
											found = true;
											xx = nx;
											yy = ny;
											//next
											direction = icvCodeDeltas[direction][i][2];
											//标记已处理
											pLabelImg[(xx)+(yy)*X] = 255;
											break;
										}
									}
									if (!found)
									{
										direction = (direction + 1) % 4;
									}

									if (growEnd = (direction == 3))
										break;
								}
							} while (!growEnd);
						}
					}
				}
			}
			//合并
			lbImage += sinPartSize >= filterSize ? sinParts : mulParts;
			//粗略计数
			cv::Mat labels, stats, centroids;
			int numObj = cv::connectedComponentsWithStats(lbImage, labels, stats, centroids);
			//清空
			memset(pLabelImg, 0, X*Y * sizeof(unsigned char));
			//画图
#define dpCent(x,y) ((double *)centroids.data)[(x)+(y)*2]
			for (int j = 1; j < numObj; j++)
			{
				cv::Point ms(cvRound(dpCent(0, j)), cvRound(dpCent(1, j)));
				pLabelImg[(ms.x) + (ms.y)*X] = 255;
			}
			//计数
			std::vector<cv::Point> vLocations;
			cv::findNonZero(lbImage, vLocations);
			for (int c = 0; c < vLocations.size(); c++)
			{
				cc.at<cv::Vec4b>(vLocations[c]) = cv::Vec4b(0, 0, 200, 255);
				cv::circle(cc, vLocations[c], 1, cv::Scalar(0, 255, 0, 255), 1);
			}
			//cv::putText(cc, std::to_string(sortedTrays[i].iDir), cv::Point(cvRound(reelCenter.x), cvRound(reelCenter.y) - 50), 0, 1.0, cv::Scalar(0, 140, 255, 255), 2);
			numObj = (int)vLocations.size();
			std::string text = std::to_string(i + 1) + ": Reel Number = ";
			text += std::to_string(numObj);
			text += " ; PartSize = " + std::to_string(sinPartSize);
			cv::putText(cc, text, cv::Point(35, 35 + i * 35), 0, 1.0, cv::Scalar(0, 140, 255, 255), 2);
			//
			trayNum[sortedTrays[i].iDir] = numObj;
			//释放资源
			free((void *)pLabelImg);
		}
		else
		{
			//采用追踪算法
			nccomps = cv::connectedComponentsWithStats(sinParts, m1, m2, m3);
			//连在一起
			cv::Mat srcPrevEx0;
			cv::morphologyEx(sinParts, srcPrevEx0, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(45, 45)));
			//定位料盘中心
			cv::findContours(srcPrevEx0, contoursFilter, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
			image = cv::Scalar(0);
			for (int i = 0; i < contoursFilter.size(); i++)
			{
				cv::drawContours(image, contoursFilter, i, cv::Scalar(255), -1);
			}
			image -= srcPrevEx0;
			//获取最大轮廓
			cv::findContours(image, contoursFilter, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
			if (contoursFilter.size() <= 0)
				continue;
			std::vector<cv::Point> contourMax = contoursFilter[0];
			for (int i = 1; i < contoursFilter.size(); i++)
			{
				if (cv::contourArea(contoursFilter[i]) > cv::contourArea(contourMax))
				{
					contourMax = contoursFilter[i];
				}
			}
			//计算最大外接圆半径
			float tFRadius = 0;
			cv::minEnclosingCircle(contourMax, cv::Point2f(), tFRadius);
			cv::Moments mu = cv::moments(contourMax);
			cv::Point2f reelCenter(float(mu.m10 / mu.m00), float(mu.m01 / mu.m00));
			//画中心
			reelCenter.x = reelCenter.x > 0 && reelCenter.x < X ? reelCenter.x : 0;
			reelCenter.y = reelCenter.y > 0 && reelCenter.y < Y ? reelCenter.y : 0;
			cv::drawMarker(cc, reelCenter, cv::Scalar(0, 0, 238, 255), 1, 35, 2);
			//包含未粘连器件
			image = cv::Scalar(0);
			std::vector<uchar> colors(nccomps + 1, 0);
			for (int i = 1; i < nccomps; i++) {
				colors[i] = 255;
				if ((((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] >= 1.5*sinPartSize) || (((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] < 0.4*sinPartSize))//经验值
				{
					colors[i] = 0;
				}
			}
			//认为是粘连
			cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
				for (int y = range.start; y < range.end; y++)
				{
					for (int x = 0; x < X; x++)
					{
						int label = ((int *)m1.data)[(x)+(y)*m1.cols];
						CV_Assert(0 <= label && label <= nccomps);
						(image.data)[(x)+(y)*X] = colors[label];
					}
				}
			});
			//去掉中心1/3区域
			cv::circle(image, reelCenter, cvRound(tFRadius / 3), cv::Scalar(0), -1);
			//追踪直至没有单个元件存在
			bool bExistSingle = true;
			//用于计数
			cv::Mat lb4Count(Y, X, CV_8UC1, cv::Scalar(0));
			//标签图
			unsigned char *ucpTrackLabel = new unsigned char[Y*X]();
			cv::Mat trackMat(Y, X, CV_8UC1, ucpTrackLabel);
			do
			{
				//不随机挑选起点(考虑换成面积最小的那个)
				std::vector<cv::Point> contourMin;
				cv::findContours(image, contoursFilter, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
				//终止追踪
				if (contoursFilter.size() <= 0) break;
				//大于等于1个随机挑选
				if (contoursFilter.size() > 1)
				{
					//随机数生成
					srand((unsigned)time(NULL));
					contourMin = contoursFilter[rand() % (contoursFilter.size() - 1)];
					for (int fc = 0; fc < contoursFilter.size(); fc++)
					{
						if (cv::contourArea(contoursFilter[fc]) > 0.4*sinPartSize)
						{
							if (cv::contourArea(contoursFilter[fc]) < cv::contourArea(contourMin))
							{
								contourMin = contoursFilter[fc];
							}
						}
					}
				}
				else if (contoursFilter.size() == 1)
				{
					contourMin = contoursFilter[0];
				}
				//去掉起始位置
				std::vector<std::vector<cv::Point>> vTempRect;
				vTempRect.push_back(contourMin);
				cv::drawContours(image, vTempRect, 0, cv::Scalar(0), -1);
				//最小外包矩形
				cv::RotatedRect rect = cv::minAreaRect(contourMin);
				cv::Point2f points[4];
				rect.points(points);
				//画图
				//for (int j = 0; j < 4; j++)
				//{
				//	cv::line(cc, points[j], points[(j + 1) % 4], cv::Scalar(0, 165, 255, 255), 1);
				//}
				//追踪起点
				cv::Point2f startCenter((points[0].x + points[1].x + points[2].x + points[3].x) / 4.f, (points[0].y + points[1].y + points[2].y + points[3].y) / 4.f);
				//打标签
				cv::Mat labels;
				nccomps = cv::connectedComponents(image, labels);
				//去掉已处理的分离器件
				std::vector<uchar> labeled(nccomps + 1, 0);
				//标记为已追踪过
				std::vector<cv::Point> vT = { cv::Point(points[0]),cv::Point(points[1]) ,cv::Point(points[2]) ,cv::Point(points[3]) };
				cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
				//起点加入计数
				cv::circle(lb4Count, cv::Point(startCenter), 0, cv::Scalar(255), 1);
				cv::circle(cc, cv::Point(startCenter), 2, cv::Scalar(0, 255, 0, 255), 1);
				///<追踪元件算法
				struct Track {
					int iLimit, iPartSize;
					double dMatchDeg;
					cv::Point Pos;
					std::vector<cv::Point2f> Rect;

					Track() {};

					Track(int iLimit, int iPartSize, double dMatchDeg, cv::Point Pos, std::vector<cv::Point2f> Rect) :iLimit(iLimit), iPartSize(iPartSize), dMatchDeg(dMatchDeg), Pos(Pos), Rect(Rect) {};

					bool operator >(const Track &te)const
					{
						return dMatchDeg > te.dMatchDeg;
					}
				};
				//扫描步长
				const double dMinorStep = 0.1;
				//追踪长宽
				const double trackLength = std::max(rect.size.width / 2, rect.size.height / 2), trackWidth = std::min(rect.size.width / 4, rect.size.height / 4);
				//起始扫描角度
				const double startAngle = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180 / PI;
				//起始扫描半径
				const double startRadius = cv::norm(startCenter - reelCenter);
				//偏移角度（元件尺寸）
				const double dOffset = (2 * asin(2 * trackLength / (2 * startRadius))) * 180 / PI;
				//偏移角度（元件间距）
				const double dScanRange = 15;
				//追踪元件间距(弦长，可以尽量避免因个别器件偏离导致的追踪中断)
				double dChordL = .0;
				for (double t = startAngle + dOffset / 1.5; t < startAngle + dOffset / 1.5 + dScanRange; t += dMinorStep)
				{
					float x = float(reelCenter.x + startRadius*cos(t*c));
					float y = float(reelCenter.y + startRadius*sin(t*c));
					//初次确定元件间距
					const double angle = atan2((double)reelCenter.y - y, (double)reelCenter.x - x);

					cv::Point p1 = cv::Point(cvRound(x + trackWidth * cos(angle)),
						cvRound(y + trackWidth * sin(angle)));

					cv::Point p2 = cv::Point(cvRound(x + trackWidth * cos(angle + CV_PI)),
						cvRound(y + trackWidth * sin(angle + CV_PI)));

					cv::LineIterator it(sinParts, p1, p2, 4);
					for (int n = 0; n < it.count; n++, ++it)
					{
						if ((sinParts.data)[(it.pos().x) + (it.pos().y)*X] == 255)
						{
							//计算元件间距（弦长）
							dChordL = 2.0 * startRadius*sin(((2.0 * asin((cv::norm(startCenter - cv::Point2f(x, y))) / (2.0 * startRadius))) * 180.0 / PI - dOffset / 2.0)*PI / 180.0 / 2.0);
							break;
						}
					}
					if (dChordL > 0)
						break;
				}
				//并行处理
				//#pragma omp parallel sections
				{
					//(顺时针)
					//#pragma omp section
					{
						//追踪中心
						cv::Point2f trackCenter = cv::Point2f(startCenter.x, startCenter.y);
						//追踪角度、半径
						double trackAngle = startAngle, trackRadius = startRadius;
						//元件本身角度
						double trackOffset = dOffset;
						//元件间间距
						double partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
						//外包矩形顶点
						cv::Point2f pts[4];
						//结束位置
						Track trackEndPos;
						//开始追踪
						bool trackEnd = true;
						do
						{
							bool found = true;
							std::vector<Track> vParts;
							for (double t = trackAngle + (trackOffset / 2.0 + partDist); t < trackAngle + (trackOffset / 2.0 + partDist) + trackOffset; t += dMinorStep)
							{
								trackCenter.x = reelCenter.x + (float)trackRadius*(float)cos(t*c);
								trackCenter.y = reelCenter.y + (float)trackRadius*(float)sin(t*c);

								float b = (float)cos(t*c)*0.5f;
								float a = (float)sin(t*c)*0.5f;
								pts[0].x = float(trackCenter.x - a*trackLength * 2 - b*trackWidth * 4);
								pts[0].y = float(trackCenter.y + b*trackLength * 2 - a*trackWidth * 4);
								pts[1].x = float(trackCenter.x + a*trackLength * 2 - b*trackWidth * 4);
								pts[1].y = float(trackCenter.y - b*trackLength * 2 - a*trackWidth * 4);
								pts[2].x = float(2 * trackCenter.x - pts[0].x);
								pts[2].y = float(2 * trackCenter.y - pts[0].y);
								pts[3].x = float(2 * trackCenter.x - pts[1].x);
								pts[3].y = float(2 * trackCenter.y - pts[1].y);

								std::vector<cv::Point> vPoints;
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								//获取内部坐标
								calcRotateRect(vRect, vPoints);
								//计算灰度值
								double dMatch = 0;
								for (int v = 0; v < vPoints.size(); v++)
								{
									if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
									{
										dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
									}
								}
								dMatch /= (double)vPoints.size();
								//仅扫描一个元件的角度
								vParts.push_back(Track(0, 0, dMatch, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), vRect));
								//cv::circle(cc, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), 0, cv::Scalar(0, 255, 255, 255), 1);
							}
							if (vParts.size() == 0) continue;
							//
							trackEndPos = vParts[vParts.size() / 2];
							//灰度极值认为是元件
							std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
							//更新位置
							trackCenter = cv::Point(vParts[0].Pos.x, vParts[0].Pos.y);
							//更新扫描角度
							trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
							//纵向扫描
							vParts.clear();
							std::vector<cv::Point> trackLine;
							drawLine(cc, reelCenter, trackCenter, cv::Scalar(0, 255, 255, 255), 1, trackLength, trackWidth * 2, trackLine);
							//更改纵向扫描方向，分两个方向?
							cv::LineIterator it(sinParts, trackLine[0], trackLine[1], 4);
							for (int n = 0; n < it.count; n++, ++it)
							{
								float b = (float)cos(trackAngle*PI / 180.)*0.5f;
								float a = (float)sin(trackAngle*PI / 180.)*0.5f;
								pts[0].x = (float)(it.pos().x - a*trackLength * 2 - b*trackWidth * 4);
								pts[0].y = (float)(it.pos().y + b*trackLength * 2 - a*trackWidth * 4);
								pts[1].x = (float)(it.pos().x + a*trackLength * 2 - b*trackWidth * 4);
								pts[1].y = (float)(it.pos().y - b*trackLength * 2 - a*trackWidth * 4);
								pts[2].x = (float)(2 * it.pos().x - pts[0].x);
								pts[2].y = (float)(2 * it.pos().y - pts[0].y);
								pts[3].x = (float)(2 * it.pos().x - pts[1].x);
								pts[3].y = (float)(2 * it.pos().y - pts[1].y);

								std::vector<cv::Point> vPoints;
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								//获取内部坐标
								calcRotateRect(vRect, vPoints);
								//计算灰度值
								int iLimit = 0, iPartSize = 0;
								double dMatch = 0;
								for (int v = 0; v < vPoints.size(); v++)
								{
									if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
									{
										iLimit += ucpTrackLabel[(vPoints[v].x) + (vPoints[v].y)*X];
										dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
										if ((sinParts.data)[(vPoints[v].x) + (vPoints[v].y)*X] == 255)
											iPartSize++;
									}
								}
								vParts.push_back(Track(iLimit, iPartSize, dMatch, it.pos(), vRect));
								//cv::circle(cc, it.pos(), 0, cv::Scalar(255, 0, 0, 255), 1);
							}
							if (vParts.size() == 0) continue;
							//方案二每个点以当前半径画圆，看下个点偏离圆多少
							//灰度极值认为是元件（最多问题出现在这里，加个条件判断矩形内是否存在已标记像素）
							std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
							//更新当前元件位置(必须不与已有元件重合)
							Track mac = vParts[0];
							if (mac.iLimit != 0)
							{
								for (int cc = 1; cc < vParts.size(); cc++)
								{
									if (vParts[cc].iLimit < mac.iLimit)
										mac = vParts[cc];
									if (mac.iLimit == 0)
										break;
								}
							}
							trackCenter = mac.Pos;
							//更新扫描半径
							trackRadius = cv::norm(trackCenter - reelCenter);
							//更新扫描角度
							trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
							//更新偏移量(元件大小)
							trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180 / PI;
							//更新元件间角度
							partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
							//判断是否结束
							if ((mac.iPartSize < sinPartSize / 4) || (trackMat.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 255) || (mac.iLimit / 255) > (rect.size.area() / 4) || (sinParts.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 0))
							{
								found = false;
								//for (int j = 0; j < 4; j++)
								//{
								//	cv::line(cc, trackEndPos.Rect[j], trackEndPos.Rect[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
								//}
								//cv::circle(cc, trackCenter, 1, cv::Scalar(0, 255, 0, 255), 1);
							}
							else
							{
								//画出最终位置
								std::vector<cv::Point> ptPoly;
								for (int j = 0; j < 4; j++)
								{
									ptPoly.push_back(cv::Point(cvRound(mac.Rect[j].x), cvRound(mac.Rect[j].y)));
									//cv::line(cc, mac.Rect[j], mac.Rect[(j + 1) % 4], cv::Scalar(0, 255, 0, 255), 1);
								}
								cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
								cv::circle(lb4Count, trackCenter, 0, cv::Scalar(255), 1);
								//标记Label
								cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));
								//获得已处理标签
								std::vector<cv::Point> vTemp;
								calcRotateRect(mac.Rect, vTemp);
								for (int p = 0; p < vTemp.size(); p++)
								{
									if (vTemp[p].x >= 0 && vTemp[p].x <= X&&vTemp[p].y >= 0 && vTemp[p].y <= Y)
									{
										int label = labels.at<int>(vTemp[p]);
										if (label != 0)
										{
											labeled[label] = 255;
											break;
										}
									}
								}
							}
							trackEnd = (!found);
						} while (!trackEnd);
					}

					//#pragma omp section 
					//逆时针追踪
					{
						//追踪起点
						cv::Point2f trackCenter(startCenter.x, startCenter.y);
						//起始扫描角度、半径
						double trackAngle = startAngle, trackRadius = startRadius;
						//元件本身角度
						double trackOffset = dOffset;
						//元件间间距
						double partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
						//当扫描一圈后修正中心位置（待测试）
						cv::Point2f pts[4];
						//结束位置
						Track trackEndPos;
						//开始追踪
						bool trackEnd = true;
						//
						do
						{
							bool found = true;
							std::vector<Track> vParts;
							for (double t = trackAngle - (partDist + trackOffset / 2.0); t > trackAngle - (partDist + trackOffset / 2.0) - trackOffset; t -= dMinorStep)
							{
								trackCenter.x = float(reelCenter.x + trackRadius*cos(t*c));
								trackCenter.y = float(reelCenter.y + trackRadius*sin(t*c));

								float b = (float)cos(t*c)*0.5f;
								float a = (float)sin(t*c)*0.5f;
								pts[0].x = (float)(trackCenter.x - a*trackLength * 2 - b*trackWidth * 4);
								pts[0].y = (float)(trackCenter.y + b*trackLength * 2 - a*trackWidth * 4);
								pts[1].x = (float)(trackCenter.x + a*trackLength * 2 - b*trackWidth * 4);
								pts[1].y = (float)(trackCenter.y - b*trackLength * 2 - a*trackWidth * 4);
								pts[2].x = (float)(2 * trackCenter.x - pts[0].x);
								pts[2].y = (float)(2 * trackCenter.y - pts[0].y);
								pts[3].x = (float)(2 * trackCenter.x - pts[1].x);
								pts[3].y = (float)(2 * trackCenter.y - pts[1].y);

								std::vector<cv::Point> vPoints;
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								//获取内部坐标
								calcRotateRect(vRect, vPoints);
								//计算灰度值
								double dMatch = 0;
								for (int v = 0; v < vPoints.size(); v++)
								{
									if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
									{
										dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
									}
								}
								dMatch /= (double)vPoints.size();
								//仅扫描一个元件的角度
								vParts.push_back(Track(0, 0, dMatch, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), vRect));
								//cv::circle(cc, trackCenter, 0, cv::Scalar(0, 255, 255, 255), 1);
							}
							if (vParts.size() == 0) continue;
							//
							trackEndPos = vParts[vParts.size() / 2];
							//灰度极值认为是元件
							std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
							//更新位置
							trackCenter = cv::Point(vParts[0].Pos.x, vParts[0].Pos.y);
							//更新扫描角度
							trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
							//纵向扫描
							vParts.clear();
							std::vector<cv::Point> trackLine;
							drawLine(cc, reelCenter, trackCenter, cv::Scalar(0, 255, 255, 255), 1, trackLength, trackWidth * 2, trackLine);
							//更改纵向扫描方向，分两个方向
							cv::LineIterator it(sinParts, trackLine[0], trackLine[1], 4);
							for (int n = 0; n < it.count; n++, ++it)
							{
								float b = (float)cos(trackAngle*PI / 180.)*0.5f;
								float a = (float)sin(trackAngle*PI / 180.)*0.5f;
								pts[0].x = (float)(it.pos().x - a*trackLength * 2 - b*trackWidth * 4);
								pts[0].y = (float)(it.pos().y + b*trackLength * 2 - a*trackWidth * 4);
								pts[1].x = (float)(it.pos().x + a*trackLength * 2 - b*trackWidth * 4);
								pts[1].y = (float)(it.pos().y - b*trackLength * 2 - a*trackWidth * 4);
								pts[2].x = (float)(2 * it.pos().x - pts[0].x);
								pts[2].y = (float)(2 * it.pos().y - pts[0].y);
								pts[3].x = (float)(2 * it.pos().x - pts[1].x);
								pts[3].y = (float)(2 * it.pos().y - pts[1].y);

								std::vector<cv::Point> vPoints;
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								//获取内部坐标
								calcRotateRect(vRect, vPoints);
								//计算灰度值
								int iLimit = 0, iPartSize = 0;
								double dMatch = 0;
								for (int v = 0; v < vPoints.size(); v++)
								{
									if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
									{
										iLimit += ucpTrackLabel[(vPoints[v].x) + (vPoints[v].y)*X];
										dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
										if ((sinParts.data)[(vPoints[v].x) + (vPoints[v].y)*X] == 255)
											iPartSize++;
									}
								}
								vParts.push_back(Track(iLimit, iPartSize, dMatch, it.pos(), vRect));
								//cv::circle(cc, it.pos(), 0, cv::Scalar(255, 0, 0, 255), 1);
							}
							if (vParts.size() == 0) continue;
							//灰度极值认为是元件
							std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
							//更新当前元件位置
							Track mac = vParts[0];
							if (mac.iLimit != 0)
							{
								for (int cc = 1; cc < vParts.size(); cc++)
								{
									if (vParts[cc].iLimit < mac.iLimit)
										mac = vParts[cc];
									if (mac.iLimit == 0)
										break;
								}
							}
							trackCenter = mac.Pos;
							//更新扫描半径
							trackRadius = cv::norm(trackCenter - reelCenter);
							//更新扫描角度
							trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
							//更新偏移量
							trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180 / PI;
							//更新追踪角度
							partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
							//绕完一周后更新料盘中心试试？
							//判断是否结束
							if (mac.iPartSize < sinPartSize / 4 || (trackMat.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 255) || (mac.iLimit / 255) >(rect.size.area() / 4) || (sinParts.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 0))
							{
								found = false;
								//for (int j = 0; j < 4; j++)
								//{
								//	cv::line(cc, trackEndPos.Rect[j], trackEndPos.Rect[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
								//}
								//cv::circle(cc, trackCenter, 1, cv::Scalar(0, 255, 0, 255), 1);
							}
							else
							{
								//画出最终位置
								std::vector<cv::Point> ptPoly;
								for (int j = 0; j < 4; j++)
								{
									ptPoly.push_back(cv::Point(cvRound(mac.Rect[j].x), cvRound(mac.Rect[j].y)));
									//cv::line(cc, mac.Rect[j], mac.Rect[(j + 1) % 4], cv::Scalar(0, 255, 0, 255), 1);
								}
								//
								cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
								cv::circle(lb4Count, trackCenter, 0, cv::Scalar(255), 1);
								//标记Label
								cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));
								//获得已处理标签
								std::vector<cv::Point> vTemp;
								calcRotateRect(mac.Rect, vTemp);
								for (int p = 0; p < vTemp.size(); p++)
								{
									if (vTemp[p].x >= 0 && vTemp[p].x <= X&&vTemp[p].y >= 0 && vTemp[p].y <= Y)
									{
										int label = labels.at<int>(vTemp[p]);
										if (label != 0)
										{
											labeled[label] = 255;
											break;
										}
									}
								}
							}
							trackEnd = (!found);
						} while (!trackEnd);
					}
				}
				//去掉已标记处理的
				cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
					for (int y = range.start; y < range.end; y++)
					{
						for (int x = 0; x < X; x++)
						{
							int label = ((int *)labels.data)[(x)+(y)*labels.cols];
							CV_Assert(0 <= label && label <= nccomps);
							if (labeled[label])
							{
								((int *)(labels.data))[(x)+(y)*X] = 0;
							}
						}
					}
				});
				image = labels > 0;
				//判断是否存在未追踪单个料
				bExistSingle = (cv::countNonZero(image) == 0);
			} while (!bExistSingle);
			//标记料盘编号
			//cv::putText(cc, std::to_string(sortedTrays[i].iDir), cv::Point(cvRound(reelCenter.x), cvRound(reelCenter.y) - 50), 0, 1.0, cv::Scalar(0, 140, 255, 255), 2);
			//计数
			int numObj = cv::countNonZero(lb4Count);
			std::string text = std::to_string(i + 1) + ": Reel Number = ";
			text += std::to_string(numObj);
			text += " ; PartSize = " + std::to_string(sinPartSize);
			cv::putText(cc, text, cv::Point(35, 35 + i * 35), 0, 1.0, cv::Scalar(0, 140, 255, 255), 2);
			//输出
			trayNum[sortedTrays[i].iDir] = numObj;
			//释放资源
			delete[] ucpTrackLabel;
			ucpTrackLabel = NULL;
		}
	}
	//输出结果
	const int bufSize = 64;
	char cTrayNum[bufSize * 4] = { 0 };
	for (int i = 0; i < trayNum.size(); i++)
	{
		char cTemp[bufSize] = { 0 };
		sprintf_s(cTemp, bufSize, "%d,", trayNum[i]);
		strcat(cTrayNum, cTemp);
	}
	//拷贝std::string拼接的字符串会莫名的报错？？
	*lpszNumObj = (char *)CoTaskMemAlloc(bufSize * 4);
	memset(*lpszNumObj, 0, bufSize * 4);
	if (NULL != *lpszNumObj)
	{
		strcpy(*lpszNumObj, cTrayNum);
	}
	//获取当前运行目录
	char buf[128];
	_getcwd(buf, sizeof(buf));
	//创建文件夹
	std::string filePath(buf);
	filePath += "\\ResOut";
	if (_access(filePath.c_str(), 0) == -1)
		_mkdir(filePath.c_str());//不存在则创建
	//格式化文件名
	char file[64 * 4] = { 0 };
	sprintf_s(file, "%s\\%s-Mark.png", filePath.c_str(), fileName);
	cv::imwrite(file, cc);
	return FUNC_OK;
}

int eyemCountObjectIrregularParts(EyemImage tpImage, const char *fileName, double dOffset, const char *ccSubType, int iMaxArea, int iWinSize, LPSTR *lpszNumObj, EyemImage *tpDstImg)
{
	cv::Mat src = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage);
	if (src.empty()) {
		return FUNC_IMAGE_NOT_EXIST;
	}
	//转单通道
	if (src.channels() != 1)
		cv::cvtColor(src, src, cv::COLOR_BGR2GRAY);

	cv::Mat src8U;
	//环鸿&佳世达
	src = src(cv::Range(200, src.cols - 70), cv::Range(200, src.rows - 10)).clone();
	//苏州公司
	//src = src(cv::Range(10, src.cols - 10), cv::Range(10, src.rows - 10)).clone();
	//图像尺寸
	int X = src.cols, Y = src.rows;
	//special for suzhou 
#define SUZHOU true
#if SUZHOU
	cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range range)->void {
		for (int y = range.start; y < range.end; y++)
		{
			for (int x = 0; x < X; x++)
			{
				if (((short *)src.data)[(x)+(y)*X] >= 4800)
				{
					((short *)src.data)[(x)+(y)*X] = 4800;
				}
			}
		}
	});
#endif
	//图像增强
	double min, max;
	cv::minMaxLoc(src, &min, &max);
	src.convertTo(src, CV_64FC1);

	src -= min;
	src /= (max - min);
	src *= 65535;
	src.convertTo(src, CV_16UC1);
	src.convertTo(src8U, CV_8UC1, 1 / 255.);
	//用于显示
	cv::Mat cc;
	cv::cvtColor(src8U, cc, cv::COLOR_GRAY2BGRA);
	//设定bin数目
	const int histSize = 17;
	//设定取值范围
	float range[] = { 0,255 };
	const float* histRange = { range };
	//计算直方图
	cv::Mat hist;
	cv::calcHist(&src8U, 1, 0, cv::Mat(), hist, 1, &histSize, &histRange);
	//计算背景像素
	int maxIdx[2] = { 255,255 };
	cv::minMaxIdx(hist, NULL, NULL, NULL, maxIdx);
	//背景阈值
	int backThresh = 15 * (maxIdx[0] - 2);
	//去掉背景
	cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range range)->void {
		for (int y = range.start; y < range.end; y++)
		{
			for (int x = 0; x < X; x++)
			{
				if ((src8U.data)[(x)+(y)*X] >= backThresh)
				{
					(src8U.data)[(x)+(y)*X] = backThresh;
				}
			}
		}
	});
	//增强到目标亮度
	cc += cv::Scalar((162 - backThresh), (162 - backThresh), (162 - backThresh));
	cv::Mat binary, srcPrev;
	cv::bitwise_not(src8U, srcPrev);
	//使用小料算法
	if (strcmp(ccSubType, "IP_SMALL_PARTS") == 0)
	{
		//二值化
		cv::threshold(srcPrev, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
		cv::morphologyEx(binary, binary, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5, 5)));
		double backPix = cv::mean(srcPrev, binary)[0];//修改背景掩膜
		//去掉背景
		cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range range)->void {
			for (int y = range.start; y < range.end; y++)
			{
				for (int x = 0; x < X; x++)
				{
					if ((srcPrev.data)[(x)+(y)*X] <= cvRound(backPix))
					{
						(srcPrev.data)[(x)+(y)*X] = cvRound(backPix);
					}
				}
			}
		});
		cv::threshold(srcPrev, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
		//待处理区域
		uchar *upMask = binary.data;
		//标签图像
		unsigned char *pLabelImg = (unsigned char *)malloc(Y*X * sizeof(unsigned char));
		memset(pLabelImg, 0, X*Y * sizeof(unsigned char));
		cv::Mat lbImage(Y, X, CV_8UC1, pLabelImg);
		//区分不同大小器件用不同的图处理
		const char icvCodeDeltas[3][3][2] = { { { 0, -1 },{ 1, -1 },{ 1, 0 } },{ { 1, 1 },{ 0,  1 },{ -1,  1 } },{ { -1,  0 },{ -1,  -1 },{ 0,  -1 } } };
#define upSrc(x, y) (srcPrev.data)[(x) + (y)*X]
		//连通域非极大值处理
		for (int y = 1; y < Y - 1; y++)
		{
			for (int x = 1; x < X - 1; x++)
			{
				//属于连通域内，并且尚未被标记
				if (upMask[(x)+(y)*X] != 0 && pLabelImg[(x)+(y)*X] != 255)
				{
					//生长种子点
					auto pixval = upSrc(x, y);
					if (pixval >= upSrc((x - 1), (y - 1)) && pixval >= upSrc((x), (y - 1)) && pixval >= upSrc((x + 1), (y - 1))\
						&& pixval >= upSrc((x + 1), (y)) && pixval >= upSrc((x + 1), (y + 1)) && pixval >= upSrc((x), (y + 1))\
						&& pixval >= upSrc((x - 1), (y + 1)) && pixval >= upSrc((x - 1), (y)))
					{
						//标记已处理
						pLabelImg[(x)+(y)*X] = 255;
						unsigned char direction = 0;
						unsigned int xx = x;
						unsigned int yy = y;
						bool growEnd = false;
						do
						{
							for (unsigned int n = 0; n < 3; n++)
							{
								bool found = false;
								for (unsigned char i = 0; i < 3; i++)
								{
									int nx = xx + icvCodeDeltas[direction][i][0];
									int ny = yy + icvCodeDeltas[direction][i][1];
									//越界处理
									if (nx < 2 || ny < 2 || nx>srcPrev.cols - 2 || ny>srcPrev.rows - 2)
										continue;

									//考虑多加个条件限制峰值
									auto val = upSrc((nx), (ny));
									if (val >= pixval&&pLabelImg[(nx)+(ny)*X] != 255)
									{
										found = true;
										xx = nx;
										yy = ny;
										//next
										direction = icvCodeDeltas[direction][i][2];
										//标记已处理
										pLabelImg[(xx)+(yy)*X] = 255;
										break;
									}
								}
								if (!found)
								{
									direction = (direction + 1) % 4;
								}

								if (growEnd = (direction == 3))
									break;
							}
						} while (!growEnd);
					}
				}
			}
		}
		//粗略计数
		cv::Mat labels, stats, centroids;
		int numObj = cv::connectedComponentsWithStats(lbImage, labels, stats, centroids);
		//坐标图
		binary = cv::Scalar(0);
		//画图
		double *dpCent = (double *)centroids.data;
		for (int j = 1; j < numObj; j++)
		{
			//cv::Point2f ms((float)dpCent[(0) + (j) * 2], (float)dpCent[(1) + (j) * 2]);
			binary.at<uchar>(cv::Point(cvRound((float)dpCent[(0) + (j) * 2]), cvRound((float)dpCent[(1) + (j) * 2]))) = 255;
		}
		//释放资源
		free((void *)pLabelImg);
	}
	//使用大料算法
	else if (strcmp(ccSubType, "IP_LARGE_PARTS") == 0)
	{
		//二值化
		cv::threshold(srcPrev, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
		cv::morphologyEx(binary, binary, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(75, 75)));
		//计算直方图
		int hist[256];
		for (int y = 0; y < 256; y++) hist[y] = 0;
		for (int y = 0; y < Y; y++)
		{
			uchar *uPtr = srcPrev.data + y * X;
			for (int x = 0; x < srcPrev.cols; x++, uPtr++)
			{
				if ((binary.data)[(x)+(y)*X] == 255)
				{
					hist[*uPtr]++;
				}
			}
		}
		cv::threshold(srcPrev, binary, Otsu(hist), 255, cv::THRESH_BINARY);
		//计算元件大小
		cv::Mat m1, m2, m3;
		int nccomps = cv::connectedComponentsWithStats(binary, m1, m2, m3);
		std::vector<uchar> colors0(nccomps + 1, 0);
		for (int i = 1; i < nccomps; i++) {
			colors0[i] = 255;
			if ((((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] <= 2))//经验值
			{
				colors0[i] = 0;
			}
		}
		//认为是干扰
		cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
			for (int y = range.start; y < range.end; y++)
			{
				for (int x = 0; x < X; x++)
				{
					int label = ((int *)m1.data)[(x)+(y)*m1.cols];
					CV_Assert(0 <= label && label <= nccomps);
					(binary.data)[(x)+(y)*X] = colors0[label];
				}
			}
		});
		nccomps = cv::connectedComponentsWithStats(binary, m1, m2, m3);
		//
		if (nccomps <= 1) return false;
		//统计元件面积
		std::vector<int> vHist(nccomps);
		for (int y = 0; y < Y; y++)
		{
			int *uPtr = (int *)m1.data + y * X;
			for (int x = 0; x < X; x++, uPtr++)
			{
				vHist[*uPtr]++;
			}
		}
		//统计面积个数
		std::map<int, int> cAreaMap;
		for (const auto& v : vHist)
		{
			std::map<int, int>::iterator it = cAreaMap.find(v);
			if (it != cAreaMap.end())
			{
				it->second++;
				continue;
			}
			else { cAreaMap.insert(std::make_pair(v, 1)); };
		}
		struct tMap
		{
			int Key;
			int Value;
			tMap(int Key, int Value) :Key(Key), Value(Value) {}

			bool operator >(const tMap &te)const
			{
				return Value > te.Value;
			}
		};
		//获得单个元器件面积(准确性待测试,假定不粘连占大多数！)
		std::vector<tMap> tVector;
		std::map<int, int>::iterator it;
		for (it = cAreaMap.begin(); it != cAreaMap.end(); it++)
		{
			tVector.push_back(tMap(it->first, it->second));
		}
		std::sort(tVector.begin(), tVector.end(), std::greater<tMap>());
		if (tVector.size() < 2)
		{
			return false;
		}
		//单个元件面积
		int sinPartSize = cvRound((tVector[0].Key + tVector[1].Key) / 2.);
		//采用追踪算法
		nccomps = cv::connectedComponentsWithStats(binary, m1, m2, m3);
		//连在一起
		cv::Mat srcPrevEx0;
		cv::morphologyEx(binary, srcPrevEx0, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(45, 45)));
		//定位料盘中心
		std::vector<std::vector<cv::Point>> contoursFilter;
		cv::findContours(srcPrevEx0, contoursFilter, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
		cv::Mat image = cv::Mat::zeros(src8U.size(), CV_8UC1);
		//
		for (int i = 0; i < contoursFilter.size(); i++)
		{
			cv::drawContours(image, contoursFilter, i, cv::Scalar(255), -1);
		}
		image -= srcPrevEx0;
		//获取最大轮廓
		cv::findContours(image, contoursFilter, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
		if (contoursFilter.size() <= 0)
			return FUNC_CANNOT_CALC;
		std::vector<cv::Point> contourMax = contoursFilter[0];
		for (int i = 1; i < contoursFilter.size(); i++)
		{
			if (cv::contourArea(contoursFilter[i]) > cv::contourArea(contourMax))
			{
				contourMax = contoursFilter[i];
			}
		}
		//计算最大外接圆半径
		float tFRadius = 0;
		cv::minEnclosingCircle(contourMax, cv::Point2f(), tFRadius);
		cv::Moments mu = cv::moments(contourMax);
		cv::Point2f reelCenter(float(mu.m10 / mu.m00), float(mu.m01 / mu.m00));
		//画中心
		reelCenter.x = reelCenter.x > 0 && reelCenter.x < X ? reelCenter.x : 0;
		reelCenter.y = reelCenter.y > 0 && reelCenter.y < Y ? reelCenter.y : 0;
		cv::drawMarker(cc, reelCenter, cv::Scalar(0, 0, 238, 255), 1, 35, 2);
		//包含未粘连器件
		image = cv::Scalar(0);
		std::vector<uchar> colors(nccomps + 1, 0);
		for (int i = 1; i < nccomps; i++) {
			colors[i] = 255;
			if ((((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] >= 1.4*sinPartSize) || (((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] < 0.4*sinPartSize))//经验值
			{
				colors[i] = 0;
			}
		}
		//认为是粘连
		cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
			for (int y = range.start; y < range.end; y++)
			{
				for (int x = 0; x < X; x++)
				{
					int label = ((int *)m1.data)[(x)+(y)*m1.cols];
					CV_Assert(0 <= label && label <= nccomps);
					(image.data)[(x)+(y)*X] = colors[label];
				}
			}
		});
		//去掉中心1/3区域
		cv::circle(image, reelCenter, cvRound(tFRadius / 3), cv::Scalar(0), -1);
		//追踪直至没有单个元件存在
		bool bExistSingle = true;
		//用于计数
		cv::Mat lb4Count(Y, X, CV_8UC1, cv::Scalar(0));
		//标签图
		unsigned char *ucpTrackLabel = new unsigned char[Y*X]();
		cv::Mat trackMat(Y, X, CV_8UC1, ucpTrackLabel);
		do
		{
			//不随机挑选起点(考虑换成面积最小的那个)
			std::vector<cv::Point> contourMin;
			cv::findContours(image, contoursFilter, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
			//终止追踪
			if (contoursFilter.size() <= 0) break;
			//大于等于1个随机挑选
			if (contoursFilter.size() > 1)
			{
				//随机数生成
				srand((unsigned)time(NULL));
				contourMin = contoursFilter[rand() % (contoursFilter.size() - 1)];
				for (int fc = 0; fc < contoursFilter.size(); fc++)
				{
					if (cv::contourArea(contoursFilter[fc]) > 0.4*sinPartSize)
					{
						if (cv::contourArea(contoursFilter[fc]) < cv::contourArea(contourMin))
						{
							contourMin = contoursFilter[fc];
						}
					}
				}
			}
			else if (contoursFilter.size() == 1)
			{
				contourMin = contoursFilter[0];
			}
			//去掉起始位置
			std::vector<std::vector<cv::Point>> vTempRect;
			vTempRect.push_back(contourMin);
			cv::drawContours(image, vTempRect, 0, cv::Scalar(0), -1);
			//最小外包矩形
			cv::RotatedRect rect = cv::minAreaRect(contourMin);
			cv::Point2f points[4];
			rect.points(points);
			//for (int j = 0; j < 4; j++)
			//{
			//	cv::line(cc, points[j], points[(j + 1) % 4], cv::Scalar(0, 165, 255, 255), 1);
			//}
			//追踪起点
			cv::Point2f startCenter((points[0].x + points[1].x + points[2].x + points[3].x) / 4.f, (points[0].y + points[1].y + points[2].y + points[3].y) / 4.f);
			//打标签
			cv::Mat labels;
			nccomps = cv::connectedComponents(image, labels);
			//去掉已处理的分离器件
			std::vector<uchar> labeled(nccomps + 1, 0);
			//标记为已追踪过
			std::vector<cv::Point> vT = { cv::Point(points[0]),cv::Point(points[1]) ,cv::Point(points[2]) ,cv::Point(points[3]) };
			cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
			//起点加入计数
			cv::circle(lb4Count, cv::Point(startCenter), 0, cv::Scalar(255), 1);
			cv::circle(cc, cv::Point(startCenter), 2, cv::Scalar(0, 255, 0, 255), 1);
			///<追踪元件算法
			struct Track {
				int iLimit, iPartSize;
				double dMatchDeg;
				cv::Point Pos;
				std::vector<cv::Point2f> Rect;

				Track() {};

				Track(int iLimit, int iPartSize, double dMatchDeg, cv::Point Pos, std::vector<cv::Point2f> Rect) :iLimit(iLimit), iPartSize(iPartSize), dMatchDeg(dMatchDeg), Pos(Pos), Rect(Rect) {};

				bool operator >(const Track &te)const
				{
					return dMatchDeg > te.dMatchDeg;
				}
			};
			//扫描步长
			const double dMinorStep = 0.1;
			//追踪长宽
			const double trackLength = std::max(rect.size.width / 2, rect.size.height / 2), trackWidth = std::min(rect.size.width / 4, rect.size.height / 4);
			//起始扫描角度
			const double startAngle = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180 / PI;
			//起始扫描半径
			const double startRadius = cv::norm(startCenter - reelCenter);
			//偏移角度（元件尺寸）
			const double dOffset = (2 * asin(2 * trackLength / (2 * startRadius))) * 180 / PI;
			//偏移角度（元件间距）
			const double dScanRange = 15;
			//追踪元件间距(弦长，可以尽量避免因个别器件偏离导致的追踪中断)
			double dChordL = .0;
			for (double t = startAngle + dOffset / 1.5; t < startAngle + dOffset / 1.5 + dScanRange; t += dMinorStep)
			{
				float x = float(reelCenter.x + startRadius*cos(t*c));
				float y = float(reelCenter.y + startRadius*sin(t*c));
				//初次确定元件间距
				const double angle = atan2((double)reelCenter.y - y, (double)reelCenter.x - x);

				cv::Point p1 = cv::Point(cvRound(x + trackWidth * cos(angle)),
					cvRound(y + trackWidth * sin(angle)));

				cv::Point p2 = cv::Point(cvRound(x + trackWidth * cos(angle + CV_PI)),
					cvRound(y + trackWidth * sin(angle + CV_PI)));

				cv::LineIterator it(binary, p1, p2, 4);
				for (int n = 0; n < it.count; n++, ++it)
				{
					if ((binary.data)[(it.pos().x) + (it.pos().y)*X] == 255)
					{
						//计算元件间距（弦长）
						dChordL = 2.0 * startRadius*sin(((2.0 * asin((cv::norm(startCenter - cv::Point2f(x, y))) / (2.0 * startRadius))) * 180.0 / PI - dOffset / 2.0)*PI / 180.0 / 2.0);
						break;
					}
				}
				if (dChordL > 0)
					break;
			}
			//并行处理
			//#pragma omp parallel sections
			{
				//(顺时针)
				//#pragma omp section
				{
					//追踪中心
					cv::Point2f trackCenter = cv::Point2f(startCenter.x, startCenter.y);
					//追踪角度、半径
					double trackAngle = startAngle, trackRadius = startRadius;
					//元件本身角度
					double trackOffset = dOffset;
					//元件间间距
					double partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
					//外包矩形顶点
					cv::Point2f pts[4];
					//结束位置
					Track trackEndPos;
					//开始追踪
					bool trackEnd = true;
					do
					{
						bool found = true;
						std::vector<Track> vParts;
						for (double t = trackAngle + (trackOffset / 2.0 + partDist); t < trackAngle + (trackOffset / 2.0 + partDist) + trackOffset; t += dMinorStep)
						{
							trackCenter.x = reelCenter.x + (float)trackRadius*(float)cos(t*c);
							trackCenter.y = reelCenter.y + (float)trackRadius*(float)sin(t*c);

							float b = (float)cos(t*c)*0.5f;
							float a = (float)sin(t*c)*0.5f;
							pts[0].x = float(trackCenter.x - a*trackLength * 2 - b*trackWidth * 4);
							pts[0].y = float(trackCenter.y + b*trackLength * 2 - a*trackWidth * 4);
							pts[1].x = float(trackCenter.x + a*trackLength * 2 - b*trackWidth * 4);
							pts[1].y = float(trackCenter.y - b*trackLength * 2 - a*trackWidth * 4);
							pts[2].x = float(2 * trackCenter.x - pts[0].x);
							pts[2].y = float(2 * trackCenter.y - pts[0].y);
							pts[3].x = float(2 * trackCenter.x - pts[1].x);
							pts[3].y = float(2 * trackCenter.y - pts[1].y);

							std::vector<cv::Point> vPoints;
							std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
							//获取内部坐标
							calcRotateRect(vRect, vPoints);
							//计算灰度值
							double dMatch = 0;
							for (int v = 0; v < vPoints.size(); v++)
							{
								if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
								{
									dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
								}
							}
							dMatch /= (double)vPoints.size();
							//仅扫描一个元件的角度
							vParts.push_back(Track(0, 0, dMatch, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), vRect));
							//cv::circle(cc, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), 0, cv::Scalar(0, 255, 255, 255), 1);
						}
						if (vParts.size() == 0) continue;
						//
						trackEndPos = vParts[vParts.size() / 2];
						//灰度极值认为是元件
						std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
						//更新位置
						trackCenter = cv::Point(vParts[0].Pos.x, vParts[0].Pos.y);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
						//纵向扫描
						vParts.clear();
						std::vector<cv::Point> trackLine;
						drawLine(cc, reelCenter, trackCenter, cv::Scalar(0, 255, 255, 255), 1, trackLength, trackWidth * 2, trackLine);
						//更改纵向扫描方向，分两个方向?
						cv::LineIterator it(binary, trackLine[0], trackLine[1], 4);
						for (int n = 0; n < it.count; n++, ++it)
						{
							float b = (float)cos(trackAngle*PI / 180.)*0.5f;
							float a = (float)sin(trackAngle*PI / 180.)*0.5f;
							pts[0].x = (float)(it.pos().x - a*trackLength * 2 - b*trackWidth * 4);
							pts[0].y = (float)(it.pos().y + b*trackLength * 2 - a*trackWidth * 4);
							pts[1].x = (float)(it.pos().x + a*trackLength * 2 - b*trackWidth * 4);
							pts[1].y = (float)(it.pos().y - b*trackLength * 2 - a*trackWidth * 4);
							pts[2].x = (float)(2 * it.pos().x - pts[0].x);
							pts[2].y = (float)(2 * it.pos().y - pts[0].y);
							pts[3].x = (float)(2 * it.pos().x - pts[1].x);
							pts[3].y = (float)(2 * it.pos().y - pts[1].y);

							std::vector<cv::Point> vPoints;
							std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
							//获取内部坐标
							calcRotateRect(vRect, vPoints);
							//计算灰度值
							int iLimit = 0, iPartSize = 0;
							double dMatch = 0;
							for (int v = 0; v < vPoints.size(); v++)
							{
								if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
								{
									iLimit += ucpTrackLabel[(vPoints[v].x) + (vPoints[v].y)*X];
									dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
									if ((binary.data)[(vPoints[v].x) + (vPoints[v].y)*X] == 255)
										iPartSize++;
								}
							}
							vParts.push_back(Track(iLimit, iPartSize, dMatch, it.pos(), vRect));
							//cv::circle(cc, it.pos(), 0, cv::Scalar(255, 0, 0, 255), 1);
						}
						if (vParts.size() == 0) continue;
						//方案二每个点以当前半径画圆，看下个点偏离圆多少
						//灰度极值认为是元件（最多问题出现在这里，加个条件判断矩形内是否存在已标记像素）
						std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
						//更新当前元件位置(必须不与已有元件重合)
						Track mac = vParts[0];
						if (mac.iLimit != 0)
						{
							for (int cc = 1; cc < vParts.size(); cc++)
							{
								if (vParts[cc].iLimit < mac.iLimit)
									mac = vParts[cc];
								if (mac.iLimit == 0)
									break;
							}
						}
						trackCenter = mac.Pos;
						//更新扫描半径
						trackRadius = cv::norm(trackCenter - reelCenter);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
						//更新偏移量(元件大小)
						trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180 / PI;
						//更新元件间角度
						partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
						//判断是否结束
						if ((mac.iPartSize < sinPartSize / 4) || (trackMat.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 255) || (mac.iLimit / 255) > (rect.size.area() / 4) || (binary.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 0))
						{
							found = false;
							//for (int j = 0; j < 4; j++)
							//{
							//	cv::line(cc, trackEndPos.Rect[j], trackEndPos.Rect[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
							//}
							//cv::circle(cc, trackCenter, 1, cv::Scalar(0, 255, 0, 255), 1);
						}
						else
						{
							//画出最终位置
							std::vector<cv::Point> ptPoly;
							for (int j = 0; j < 4; j++)
							{
								ptPoly.push_back(cv::Point(cvRound(mac.Rect[j].x), cvRound(mac.Rect[j].y)));
								//cv::line(cc, mac.Rect[j], mac.Rect[(j + 1) % 4], cv::Scalar(0, 255, 0, 255), 1);
							}
							cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
							cv::circle(lb4Count, trackCenter, 0, cv::Scalar(255), 1);
							//标记Label
							cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));
							//获得已处理标签
							std::vector<cv::Point> vTemp;
							calcRotateRect(mac.Rect, vTemp);
							for (int p = 0; p < vTemp.size(); p++)
							{
								if (vTemp[p].x >= 0 && vTemp[p].x <= X&&vTemp[p].y >= 0 && vTemp[p].y <= Y)
								{
									int label = labels.at<int>(vTemp[p]);
									if (label != 0)
									{
										labeled[label] = 255;
										break;
									}
								}
							}
						}
						trackEnd = (!found);
					} while (!trackEnd);
				}

				//#pragma omp section 
				//逆时针追踪
				{
					//追踪起点
					cv::Point2f trackCenter(startCenter.x, startCenter.y);
					//起始扫描角度、半径
					double trackAngle = startAngle, trackRadius = startRadius;
					//元件本身角度
					double trackOffset = dOffset;
					//元件间间距
					double partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
					//当扫描一圈后修正中心位置（待测试）
					cv::Point2f pts[4];
					//结束位置
					Track trackEndPos;
					//开始追踪
					bool trackEnd = true;
					//
					do
					{
						bool found = true;
						std::vector<Track> vParts;
						for (double t = trackAngle - (partDist + trackOffset / 2.0); t > trackAngle - (partDist + trackOffset / 2.0) - trackOffset; t -= dMinorStep)
						{
							trackCenter.x = float(reelCenter.x + trackRadius*cos(t*c));
							trackCenter.y = float(reelCenter.y + trackRadius*sin(t*c));

							float b = (float)cos(t*c)*0.5f;
							float a = (float)sin(t*c)*0.5f;
							pts[0].x = (float)(trackCenter.x - a*trackLength * 2 - b*trackWidth * 4);
							pts[0].y = (float)(trackCenter.y + b*trackLength * 2 - a*trackWidth * 4);
							pts[1].x = (float)(trackCenter.x + a*trackLength * 2 - b*trackWidth * 4);
							pts[1].y = (float)(trackCenter.y - b*trackLength * 2 - a*trackWidth * 4);
							pts[2].x = (float)(2 * trackCenter.x - pts[0].x);
							pts[2].y = (float)(2 * trackCenter.y - pts[0].y);
							pts[3].x = (float)(2 * trackCenter.x - pts[1].x);
							pts[3].y = (float)(2 * trackCenter.y - pts[1].y);

							std::vector<cv::Point> vPoints;
							std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
							//获取内部坐标
							calcRotateRect(vRect, vPoints);
							//计算灰度值
							double dMatch = 0;
							for (int v = 0; v < vPoints.size(); v++)
							{
								if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
								{
									dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
								}
							}
							dMatch /= (double)vPoints.size();
							//仅扫描一个元件的角度
							vParts.push_back(Track(0, 0, dMatch, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), vRect));
							//cv::circle(cc, trackCenter, 0, cv::Scalar(0, 255, 255, 255), 1);
						}
						if (vParts.size() == 0) continue;
						//
						trackEndPos = vParts[vParts.size() / 2];
						//灰度极值认为是元件
						std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
						//更新位置
						trackCenter = cv::Point(vParts[0].Pos.x, vParts[0].Pos.y);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
						//纵向扫描
						vParts.clear();
						std::vector<cv::Point> trackLine;
						drawLine(cc, reelCenter, trackCenter, cv::Scalar(0, 255, 255, 255), 1, trackLength, trackWidth * 2, trackLine);
						//更改纵向扫描方向，分两个方向
						cv::LineIterator it(binary, trackLine[0], trackLine[1], 4);
						for (int n = 0; n < it.count; n++, ++it)
						{
							float b = (float)cos(trackAngle*PI / 180.)*0.5f;
							float a = (float)sin(trackAngle*PI / 180.)*0.5f;
							pts[0].x = (float)(it.pos().x - a*trackLength * 2 - b*trackWidth * 4);
							pts[0].y = (float)(it.pos().y + b*trackLength * 2 - a*trackWidth * 4);
							pts[1].x = (float)(it.pos().x + a*trackLength * 2 - b*trackWidth * 4);
							pts[1].y = (float)(it.pos().y - b*trackLength * 2 - a*trackWidth * 4);
							pts[2].x = (float)(2 * it.pos().x - pts[0].x);
							pts[2].y = (float)(2 * it.pos().y - pts[0].y);
							pts[3].x = (float)(2 * it.pos().x - pts[1].x);
							pts[3].y = (float)(2 * it.pos().y - pts[1].y);

							std::vector<cv::Point> vPoints;
							std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
							//获取内部坐标
							calcRotateRect(vRect, vPoints);
							//计算灰度值
							int iLimit = 0, iPartSize = 0;
							double dMatch = 0;
							for (int v = 0; v < vPoints.size(); v++)
							{
								if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
								{
									iLimit += ucpTrackLabel[(vPoints[v].x) + (vPoints[v].y)*X];
									dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
									if ((binary.data)[(vPoints[v].x) + (vPoints[v].y)*X] == 255)
										iPartSize++;
								}
							}
							vParts.push_back(Track(iLimit, iPartSize, dMatch, it.pos(), vRect));
							//cv::circle(cc, it.pos(), 0, cv::Scalar(255, 0, 0, 255), 1);
						}
						if (vParts.size() == 0) continue;
						//灰度极值认为是元件
						std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
						//更新当前元件位置
						Track mac = vParts[0];
						if (mac.iLimit != 0)
						{
							for (int cc = 1; cc < vParts.size(); cc++)
							{
								if (vParts[cc].iLimit < mac.iLimit)
									mac = vParts[cc];
								if (mac.iLimit == 0)
									break;
							}
						}
						trackCenter = mac.Pos;
						//更新扫描半径
						trackRadius = cv::norm(trackCenter - reelCenter);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
						//更新偏移量
						trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180 / PI;
						//更新追踪角度
						partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
						//绕完一周后更新料盘中心试试？
						//判断是否结束
						if (mac.iPartSize < sinPartSize / 4 || (trackMat.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 255) || (mac.iLimit / 255) >(rect.size.area() / 4) || (binary.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 0))
						{
							found = false;
							//for (int j = 0; j < 4; j++)
							//{
							//	cv::line(cc, trackEndPos.Rect[j], trackEndPos.Rect[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
							//}
							//cv::circle(cc, trackCenter, 1, cv::Scalar(0, 255, 0, 255), 1);
						}
						else
						{
							//画出最终位置
							std::vector<cv::Point> ptPoly;
							for (int j = 0; j < 4; j++)
							{
								ptPoly.push_back(cv::Point(cvRound(mac.Rect[j].x), cvRound(mac.Rect[j].y)));
								//cv::line(cc, mac.Rect[j], mac.Rect[(j + 1) % 4], cv::Scalar(0, 255, 0, 255), 1);
							}
							//
							cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
							cv::circle(lb4Count, trackCenter, 0, cv::Scalar(255), 1);
							//标记Label
							cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));
							//获得已处理标签
							std::vector<cv::Point> vTemp;
							calcRotateRect(mac.Rect, vTemp);
							for (int p = 0; p < vTemp.size(); p++)
							{
								if (vTemp[p].x >= 0 && vTemp[p].x <= X&&vTemp[p].y >= 0 && vTemp[p].y <= Y)
								{
									int label = labels.at<int>(vTemp[p]);
									if (label != 0)
									{
										labeled[label] = 255;
										break;
									}
								}
							}
						}
						trackEnd = (!found);
					} while (!trackEnd);
				}
			}
			//去掉已标记处理的
			cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
				for (int y = range.start; y < range.end; y++)
				{
					for (int x = 0; x < X; x++)
					{
						int label = ((int *)labels.data)[(x)+(y)*labels.cols];
						CV_Assert(0 <= label && label <= nccomps);
						if (labeled[label])
						{
							((int *)(labels.data))[(x)+(y)*X] = 0;
						}
					}
				}
			});
			image = labels > 0;
			//判断是否存在未追踪单个料
			bExistSingle = (cv::countNonZero(image) == 0);
		} while (!bExistSingle);
		//拷贝计数
		binary = lb4Count.clone();
		//释放资源
		delete[] ucpTrackLabel;
		ucpTrackLabel = NULL;
	}
	//对单个器件间存在断裂使用,及料盘内圈颜色过深
	else if (strcmp(ccSubType, "IP_LONG_PARTS") == 0)
	{
		//二值化
		cv::threshold(srcPrev, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
		cv::morphologyEx(binary, binary, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(75, 75)));
		//计算直方图
		int hist[256];
		for (int y = 0; y < 256; y++) hist[y] = 0;
		for (int y = 0; y < Y; y++)
		{
			uchar *uPtr = srcPrev.data + y * X;
			for (int x = 0; x < srcPrev.cols; x++, uPtr++)
			{
				if ((binary.data)[(x)+(y)*X] == 255)
				{
					hist[*uPtr]++;
				}
			}
		}
		cv::threshold(srcPrev, binary, Otsu(hist), 255, cv::THRESH_BINARY);
		//去掉料盘深色部分
		cv::Mat srcPrevEx;
		cv::morphologyEx(srcPrev, srcPrevEx, cv::MORPH_TOPHAT, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3)));
		cv::threshold(srcPrevEx, srcPrevEx, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
		//获得元件区域
		cv::morphologyEx(srcPrevEx, srcPrevEx, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(75, 75)));
		//去掉干扰
		binary &= srcPrevEx;
		//将断裂处连接在一起?
		cv::morphologyEx(binary, binary, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3)));
		//计算元件大小
		cv::Mat m1, m2, m3;
		int nccomps = cv::connectedComponentsWithStats(binary, m1, m2, m3);
		std::vector<uchar> colors0(nccomps + 1, 0);
		for (int i = 1; i < nccomps; i++) {
			colors0[i] = 255;
			if ((((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] <= 2))//经验值
			{
				colors0[i] = 0;
			}
		}
		//认为是干扰
		cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
			for (int y = range.start; y < range.end; y++)
			{
				for (int x = 0; x < X; x++)
				{
					int label = ((int *)m1.data)[(x)+(y)*m1.cols];
					CV_Assert(0 <= label && label <= nccomps);
					(binary.data)[(x)+(y)*X] = colors0[label];
				}
			}
		});
		nccomps = cv::connectedComponentsWithStats(binary, m1, m2, m3);
		//
		if (nccomps <= 1) return false;
		//统计元件面积
		std::vector<int> vHist(nccomps);
		for (int y = 0; y < Y; y++)
		{
			int *uPtr = (int *)m1.data + y * X;
			for (int x = 0; x < X; x++, uPtr++)
			{
				vHist[*uPtr]++;
			}
		}
		//统计面积个数
		std::map<int, int> cAreaMap;
		for (const auto& v : vHist)
		{
			std::map<int, int>::iterator it = cAreaMap.find(v);
			if (it != cAreaMap.end())
			{
				it->second++;
				continue;
			}
			else { cAreaMap.insert(std::make_pair(v, 1)); };
		}
		struct tMap
		{
			int Key;
			int Value;
			tMap(int Key, int Value) :Key(Key), Value(Value) {}

			bool operator >(const tMap &te)const
			{
				return Value > te.Value;
			}
		};
		//获得单个元器件面积(准确性待测试,假定不粘连占大多数！)
		std::vector<tMap> tVector;
		std::map<int, int>::iterator it;
		for (it = cAreaMap.begin(); it != cAreaMap.end(); it++)
		{
			tVector.push_back(tMap(it->first, it->second));
		}
		std::sort(tVector.begin(), tVector.end(), std::greater<tMap>());
		if (tVector.size() < 2)
		{
			return FUNC_CANNOT_CALC;
		}
		//单个元件面积
		int sinPartSize = cvRound((tVector[0].Key + tVector[1].Key) / 2.);
		//采用追踪算法
		nccomps = cv::connectedComponentsWithStats(binary, m1, m2, m3);
		//连在一起
		cv::Mat srcPrevEx0;
		cv::morphologyEx(binary, srcPrevEx0, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(45, 45)));
		//定位料盘中心
		std::vector<std::vector<cv::Point>> contoursFilter;
		cv::findContours(srcPrevEx0, contoursFilter, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
		cv::Mat image = cv::Mat::zeros(src8U.size(), CV_8UC1);
		//
		for (int i = 0; i < contoursFilter.size(); i++)
		{
			cv::drawContours(image, contoursFilter, i, cv::Scalar(255), -1);
		}
		image -= srcPrevEx0;
		//获取最大轮廓
		cv::findContours(image, contoursFilter, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
		if (contoursFilter.size() <= 0)
			return FUNC_CANNOT_CALC;
		std::vector<cv::Point> contourMax = contoursFilter[0];
		for (int i = 1; i < contoursFilter.size(); i++)
		{
			if (cv::contourArea(contoursFilter[i]) > cv::contourArea(contourMax))
			{
				contourMax = contoursFilter[i];
			}
		}
		//计算最大外接圆半径
		float tFRadius = 0;
		cv::minEnclosingCircle(contourMax, cv::Point2f(), tFRadius);
		cv::Moments mu = cv::moments(contourMax);
		cv::Point2f reelCenter(float(mu.m10 / mu.m00), float(mu.m01 / mu.m00));
		//画中心
		reelCenter.x = reelCenter.x > 0 && reelCenter.x < X ? reelCenter.x : 0;
		reelCenter.y = reelCenter.y > 0 && reelCenter.y < Y ? reelCenter.y : 0;
		cv::drawMarker(cc, reelCenter, cv::Scalar(0, 0, 238, 255), 1, 35, 2);
		//包含未粘连器件
		image = cv::Scalar(0);
		std::vector<uchar> colors(nccomps + 1, 0);
		for (int i = 1; i < nccomps; i++) {
			colors[i] = 255;
			if ((((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] >= 1.5*sinPartSize) || (((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] < 0.4*sinPartSize))//经验值
			{
				colors[i] = 0;
			}
		}
		//认为是粘连
		cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
			for (int y = range.start; y < range.end; y++)
			{
				for (int x = 0; x < X; x++)
				{
					int label = ((int *)m1.data)[(x)+(y)*m1.cols];
					CV_Assert(0 <= label && label <= nccomps);
					(image.data)[(x)+(y)*X] = colors[label];
				}
			}
		});
		//去掉中心1/3区域
		cv::circle(image, reelCenter, cvRound(tFRadius / 3), cv::Scalar(0), -1);
		//追踪直至没有单个元件存在
		bool bExistSingle = true;
		//用于计数
		cv::Mat lb4Count(Y, X, CV_8UC1, cv::Scalar(0));
		//标签图
		unsigned char *ucpTrackLabel = new unsigned char[Y*X]();
		cv::Mat trackMat(Y, X, CV_8UC1, ucpTrackLabel);
		do
		{
			//不随机挑选起点(考虑换成面积最小的那个)
			std::vector<cv::Point> contourMin;
			cv::findContours(image, contoursFilter, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
			//终止追踪
			if (contoursFilter.size() <= 0) break;
			//大于等于1个随机挑选
			if (contoursFilter.size() > 1)
			{
				//随机数生成
				srand((unsigned)time(NULL));
				contourMin = contoursFilter[rand() % (contoursFilter.size() - 1)];
				for (int fc = 0; fc < contoursFilter.size(); fc++)
				{
					if (cv::contourArea(contoursFilter[fc]) > 0.4*sinPartSize)
					{
						if (cv::contourArea(contoursFilter[fc]) < cv::contourArea(contourMin))
						{
							contourMin = contoursFilter[fc];
						}
					}
				}
			}
			else if (contoursFilter.size() == 1)
			{
				contourMin = contoursFilter[0];
			}
			//去掉起始位置
			std::vector<std::vector<cv::Point>> vTempRect;
			vTempRect.push_back(contourMin);
			cv::drawContours(image, vTempRect, 0, cv::Scalar(0), -1);
			//最小外包矩形
			cv::RotatedRect rect = cv::minAreaRect(contourMin);
			cv::Point2f points[4];
			rect.points(points);
			//for (int j = 0; j < 4; j++)
			//{
			//	cv::line(cc, points[j], points[(j + 1) % 4], cv::Scalar(0, 165, 255, 255), 1);
			//}
			//追踪起点
			cv::Point2f startCenter((points[0].x + points[1].x + points[2].x + points[3].x) / 4.f, (points[0].y + points[1].y + points[2].y + points[3].y) / 4.f);
			//打标签
			cv::Mat labels;
			nccomps = cv::connectedComponents(image, labels);
			//去掉已处理的分离器件
			std::vector<uchar> labeled(nccomps + 1, 0);
			//标记为已追踪过
			std::vector<cv::Point> vT = { cv::Point(points[0]),cv::Point(points[1]) ,cv::Point(points[2]) ,cv::Point(points[3]) };
			cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
			//起点加入计数
			cv::circle(lb4Count, cv::Point(startCenter), 0, cv::Scalar(255), 1);
			cv::circle(cc, cv::Point(startCenter), 2, cv::Scalar(0, 255, 0, 255), 1);
			///<追踪元件算法
			struct Track {
				int iLimit, iPartSize;
				double dMatchDeg;
				cv::Point Pos;
				std::vector<cv::Point2f> Rect;

				Track() {};

				Track(int iLimit, int iPartSize, double dMatchDeg, cv::Point Pos, std::vector<cv::Point2f> Rect) :iLimit(iLimit), iPartSize(iPartSize), dMatchDeg(dMatchDeg), Pos(Pos), Rect(Rect) {};

				bool operator >(const Track &te)const
				{
					return dMatchDeg > te.dMatchDeg;
				}
			};
			//扫描步长
			const double dMinorStep = 0.1;
			//追踪长宽
			const double trackLength = std::max(rect.size.width / 2, rect.size.height / 2), trackWidth = std::min(rect.size.width / 4, rect.size.height / 4);
			//起始扫描角度
			const double startAngle = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180 / PI;
			//起始扫描半径
			const double startRadius = cv::norm(startCenter - reelCenter);
			//偏移角度（元件尺寸）
			const double dOffset = (2 * asin(2 * trackLength / (2 * startRadius))) * 180 / PI;
			//偏移角度（元件间距）
			const double dScanRange = 15;
			//追踪元件间距(弦长，可以尽量避免因个别器件偏离导致的追踪中断)
			double dChordL = .0;
			for (double t = startAngle + dOffset / 1.5; t < startAngle + dOffset / 1.5 + dScanRange; t += dMinorStep)
			{
				float x = float(reelCenter.x + startRadius*cos(t*c));
				float y = float(reelCenter.y + startRadius*sin(t*c));
				//初次确定元件间距
				const double angle = atan2((double)reelCenter.y - y, (double)reelCenter.x - x);

				cv::Point p1 = cv::Point(cvRound(x + trackWidth * cos(angle)),
					cvRound(y + trackWidth * sin(angle)));

				cv::Point p2 = cv::Point(cvRound(x + trackWidth * cos(angle + CV_PI)),
					cvRound(y + trackWidth * sin(angle + CV_PI)));

				cv::LineIterator it(binary, p1, p2, 4);
				for (int n = 0; n < it.count; n++, ++it)
				{
					if ((binary.data)[(it.pos().x) + (it.pos().y)*X] == 255)
					{
						//计算元件间距（弦长）
						dChordL = 2.0 * startRadius*sin(((2.0 * asin((cv::norm(startCenter - cv::Point2f(x, y))) / (2.0 * startRadius))) * 180.0 / PI - dOffset / 2.0)*PI / 180.0 / 2.0);
						break;
					}
				}
				if (dChordL > 0)
					break;
			}
			//并行处理
			//#pragma omp parallel sections
			{
				//(顺时针)
				//#pragma omp section
				{
					//追踪中心
					cv::Point2f trackCenter = cv::Point2f(startCenter.x, startCenter.y);
					//追踪角度、半径
					double trackAngle = startAngle, trackRadius = startRadius;
					//元件本身角度
					double trackOffset = dOffset;
					//元件间间距
					double partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
					//外包矩形顶点
					cv::Point2f pts[4];
					//结束位置
					Track trackEndPos;
					//开始追踪
					bool trackEnd = true;
					do
					{
						bool found = true;
						std::vector<Track> vParts;
						for (double t = trackAngle + (trackOffset / 2.0 + partDist); t < trackAngle + (trackOffset / 2.0 + partDist) + trackOffset; t += dMinorStep)
						{
							trackCenter.x = reelCenter.x + (float)trackRadius*(float)cos(t*c);
							trackCenter.y = reelCenter.y + (float)trackRadius*(float)sin(t*c);

							float b = (float)cos(t*c)*0.5f;
							float a = (float)sin(t*c)*0.5f;
							pts[0].x = float(trackCenter.x - a*trackLength * 2 - b*trackWidth * 4);
							pts[0].y = float(trackCenter.y + b*trackLength * 2 - a*trackWidth * 4);
							pts[1].x = float(trackCenter.x + a*trackLength * 2 - b*trackWidth * 4);
							pts[1].y = float(trackCenter.y - b*trackLength * 2 - a*trackWidth * 4);
							pts[2].x = float(2 * trackCenter.x - pts[0].x);
							pts[2].y = float(2 * trackCenter.y - pts[0].y);
							pts[3].x = float(2 * trackCenter.x - pts[1].x);
							pts[3].y = float(2 * trackCenter.y - pts[1].y);

							std::vector<cv::Point> vPoints;
							std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
							//获取内部坐标
							calcRotateRect(vRect, vPoints);
							//计算灰度值
							double dMatch = 0;
							for (int v = 0; v < vPoints.size(); v++)
							{
								if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
								{
									dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
								}
							}
							dMatch /= (double)vPoints.size();
							//仅扫描一个元件的角度
							vParts.push_back(Track(0, 0, dMatch, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), vRect));
							//cv::circle(cc, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), 0, cv::Scalar(0, 255, 255, 255), 1);
						}
						if (vParts.size() == 0) continue;
						//
						trackEndPos = vParts[vParts.size() / 2];
						//灰度极值认为是元件
						std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
						//更新位置
						trackCenter = cv::Point(vParts[0].Pos.x, vParts[0].Pos.y);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
						//纵向扫描
						vParts.clear();
						std::vector<cv::Point> trackLine;
						drawLine(cc, reelCenter, trackCenter, cv::Scalar(0, 255, 255, 255), 1, trackLength, trackWidth * 2, trackLine);
						//更改纵向扫描方向，分两个方向?
						cv::LineIterator it(binary, trackLine[0], trackLine[1], 4);
						for (int n = 0; n < it.count; n++, ++it)
						{
							float b = (float)cos(trackAngle*PI / 180.)*0.5f;
							float a = (float)sin(trackAngle*PI / 180.)*0.5f;
							pts[0].x = (float)(it.pos().x - a*trackLength * 2 - b*trackWidth * 4);
							pts[0].y = (float)(it.pos().y + b*trackLength * 2 - a*trackWidth * 4);
							pts[1].x = (float)(it.pos().x + a*trackLength * 2 - b*trackWidth * 4);
							pts[1].y = (float)(it.pos().y - b*trackLength * 2 - a*trackWidth * 4);
							pts[2].x = (float)(2 * it.pos().x - pts[0].x);
							pts[2].y = (float)(2 * it.pos().y - pts[0].y);
							pts[3].x = (float)(2 * it.pos().x - pts[1].x);
							pts[3].y = (float)(2 * it.pos().y - pts[1].y);

							std::vector<cv::Point> vPoints;
							std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
							//获取内部坐标
							calcRotateRect(vRect, vPoints);
							//计算灰度值
							int iLimit = 0, iPartSize = 0;
							double dMatch = 0;
							for (int v = 0; v < vPoints.size(); v++)
							{
								if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
								{
									iLimit += ucpTrackLabel[(vPoints[v].x) + (vPoints[v].y)*X];
									dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
									if ((binary.data)[(vPoints[v].x) + (vPoints[v].y)*X] == 255)
										iPartSize++;
								}
							}
							vParts.push_back(Track(iLimit, iPartSize, dMatch, it.pos(), vRect));
							//cv::circle(cc, it.pos(), 0, cv::Scalar(255, 0, 0, 255), 1);
						}
						if (vParts.size() == 0) continue;
						//方案二每个点以当前半径画圆，看下个点偏离圆多少
						//灰度极值认为是元件（最多问题出现在这里，加个条件判断矩形内是否存在已标记像素）
						std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
						//更新当前元件位置(必须不与已有元件重合)
						Track mac = vParts[0];
						if (mac.iLimit != 0)
						{
							for (int cc = 1; cc < vParts.size(); cc++)
							{
								if (vParts[cc].iLimit < mac.iLimit)
									mac = vParts[cc];
								if (mac.iLimit == 0)
									break;
							}
						}
						trackCenter = mac.Pos;
						//更新扫描半径
						trackRadius = cv::norm(trackCenter - reelCenter);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
						//更新偏移量(元件大小)
						trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180 / PI;
						//更新元件间角度
						partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
						//判断是否结束
						if ((mac.iPartSize < sinPartSize / 4) || (trackMat.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 255) || (mac.iLimit / 255) > (rect.size.area() / 4) || (binary.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 0))
						{
							found = false;
							//for (int j = 0; j < 4; j++)
							//{
							//	cv::line(cc, trackEndPos.Rect[j], trackEndPos.Rect[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
							//}
							//cv::circle(cc, trackCenter, 1, cv::Scalar(0, 255, 0, 255), 1);
						}
						else
						{
							//画出最终位置
							std::vector<cv::Point> ptPoly;
							for (int j = 0; j < 4; j++)
							{
								ptPoly.push_back(cv::Point(cvRound(mac.Rect[j].x), cvRound(mac.Rect[j].y)));
								//cv::line(cc, mac.Rect[j], mac.Rect[(j + 1) % 4], cv::Scalar(0, 255, 0, 255), 1);
							}
							cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
							cv::circle(lb4Count, trackCenter, 0, cv::Scalar(255), 1);
							//标记Label
							cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));
							//获得已处理标签
							std::vector<cv::Point> vTemp;
							calcRotateRect(mac.Rect, vTemp);
							for (int p = 0; p < vTemp.size(); p++)
							{
								if (vTemp[p].x >= 0 && vTemp[p].x <= X&&vTemp[p].y >= 0 && vTemp[p].y <= Y)
								{
									int label = labels.at<int>(vTemp[p]);
									if (label != 0)
									{
										labeled[label] = 255;
										break;
									}
								}
							}
						}
						trackEnd = (!found);
					} while (!trackEnd);
				}

				//#pragma omp section 
				//逆时针追踪
				{
					//追踪起点
					cv::Point2f trackCenter(startCenter.x, startCenter.y);
					//起始扫描角度、半径
					double trackAngle = startAngle, trackRadius = startRadius;
					//元件本身角度
					double trackOffset = dOffset;
					//元件间间距
					double partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
					//当扫描一圈后修正中心位置（待测试）
					cv::Point2f pts[4];
					//结束位置
					Track trackEndPos;
					//开始追踪
					bool trackEnd = true;
					//
					do
					{
						bool found = true;
						std::vector<Track> vParts;
						for (double t = trackAngle - (partDist + trackOffset / 2.0); t > trackAngle - (partDist + trackOffset / 2.0) - trackOffset; t -= dMinorStep)
						{
							trackCenter.x = float(reelCenter.x + trackRadius*cos(t*c));
							trackCenter.y = float(reelCenter.y + trackRadius*sin(t*c));

							float b = (float)cos(t*c)*0.5f;
							float a = (float)sin(t*c)*0.5f;
							pts[0].x = (float)(trackCenter.x - a*trackLength * 2 - b*trackWidth * 4);
							pts[0].y = (float)(trackCenter.y + b*trackLength * 2 - a*trackWidth * 4);
							pts[1].x = (float)(trackCenter.x + a*trackLength * 2 - b*trackWidth * 4);
							pts[1].y = (float)(trackCenter.y - b*trackLength * 2 - a*trackWidth * 4);
							pts[2].x = (float)(2 * trackCenter.x - pts[0].x);
							pts[2].y = (float)(2 * trackCenter.y - pts[0].y);
							pts[3].x = (float)(2 * trackCenter.x - pts[1].x);
							pts[3].y = (float)(2 * trackCenter.y - pts[1].y);

							std::vector<cv::Point> vPoints;
							std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
							//获取内部坐标
							calcRotateRect(vRect, vPoints);
							//计算灰度值
							double dMatch = 0;
							for (int v = 0; v < vPoints.size(); v++)
							{
								if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
								{
									dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
								}
							}
							dMatch /= (double)vPoints.size();
							//仅扫描一个元件的角度
							vParts.push_back(Track(0, 0, dMatch, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), vRect));
							//cv::circle(cc, trackCenter, 0, cv::Scalar(0, 255, 255, 255), 1);
						}
						if (vParts.size() == 0) continue;
						//
						trackEndPos = vParts[vParts.size() / 2];
						//灰度极值认为是元件
						std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
						//更新位置
						trackCenter = cv::Point(vParts[0].Pos.x, vParts[0].Pos.y);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
						//纵向扫描
						vParts.clear();
						std::vector<cv::Point> trackLine;
						drawLine(cc, reelCenter, trackCenter, cv::Scalar(0, 255, 255, 255), 1, trackLength, trackWidth * 2, trackLine);
						//更改纵向扫描方向，分两个方向
						cv::LineIterator it(binary, trackLine[0], trackLine[1], 4);
						for (int n = 0; n < it.count; n++, ++it)
						{
							float b = (float)cos(trackAngle*PI / 180.)*0.5f;
							float a = (float)sin(trackAngle*PI / 180.)*0.5f;
							pts[0].x = (float)(it.pos().x - a*trackLength * 2 - b*trackWidth * 4);
							pts[0].y = (float)(it.pos().y + b*trackLength * 2 - a*trackWidth * 4);
							pts[1].x = (float)(it.pos().x + a*trackLength * 2 - b*trackWidth * 4);
							pts[1].y = (float)(it.pos().y - b*trackLength * 2 - a*trackWidth * 4);
							pts[2].x = (float)(2 * it.pos().x - pts[0].x);
							pts[2].y = (float)(2 * it.pos().y - pts[0].y);
							pts[3].x = (float)(2 * it.pos().x - pts[1].x);
							pts[3].y = (float)(2 * it.pos().y - pts[1].y);

							std::vector<cv::Point> vPoints;
							std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
							//获取内部坐标
							calcRotateRect(vRect, vPoints);
							//计算灰度值
							int iLimit = 0, iPartSize = 0;
							double dMatch = 0;
							for (int v = 0; v < vPoints.size(); v++)
							{
								if (vPoints[v].x >= 0 && vPoints[v].x <= X&&vPoints[v].y >= 0 && vPoints[v].y <= Y)
								{
									iLimit += ucpTrackLabel[(vPoints[v].x) + (vPoints[v].y)*X];
									dMatch += (srcPrev.data)[(vPoints[v].x) + (vPoints[v].y)*X];
									if ((binary.data)[(vPoints[v].x) + (vPoints[v].y)*X] == 255)
										iPartSize++;
								}
							}
							vParts.push_back(Track(iLimit, iPartSize, dMatch, it.pos(), vRect));
							//cv::circle(cc, it.pos(), 0, cv::Scalar(255, 0, 0, 255), 1);
						}
						if (vParts.size() == 0) continue;
						//灰度极值认为是元件
						std::sort(vParts.begin(), vParts.end(), std::greater<Track>());
						//更新当前元件位置
						Track mac = vParts[0];
						if (mac.iLimit != 0)
						{
							for (int cc = 1; cc < vParts.size(); cc++)
							{
								if (vParts[cc].iLimit < mac.iLimit)
									mac = vParts[cc];
								if (mac.iLimit == 0)
									break;
							}
						}
						trackCenter = mac.Pos;
						//更新扫描半径
						trackRadius = cv::norm(trackCenter - reelCenter);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;
						//更新偏移量
						trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180 / PI;
						//更新追踪角度
						partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180 / PI;
						//绕完一周后更新料盘中心试试？
						//判断是否结束
						if (mac.iPartSize < sinPartSize / 4 || (trackMat.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 255) || (mac.iLimit / 255) >(rect.size.area() / 4) || (binary.at<uchar>((cvRound(trackCenter.y)), (cvRound(trackCenter.x))) == 0))
						{
							found = false;
							//for (int j = 0; j < 4; j++)
							//{
							//	cv::line(cc, trackEndPos.Rect[j], trackEndPos.Rect[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
							//}
							//cv::circle(cc, trackCenter, 1, cv::Scalar(0, 255, 0, 255), 1);
						}
						else
						{
							//画出最终位置
							std::vector<cv::Point> ptPoly;
							for (int j = 0; j < 4; j++)
							{
								ptPoly.push_back(cv::Point(cvRound(mac.Rect[j].x), cvRound(mac.Rect[j].y)));
								//cv::line(cc, mac.Rect[j], mac.Rect[(j + 1) % 4], cv::Scalar(0, 255, 0, 255), 1);
							}
							//
							cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
							cv::circle(lb4Count, trackCenter, 0, cv::Scalar(255), 1);
							//标记Label
							cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));
							//获得已处理标签
							std::vector<cv::Point> vTemp;
							calcRotateRect(mac.Rect, vTemp);
							for (int p = 0; p < vTemp.size(); p++)
							{
								if (vTemp[p].x >= 0 && vTemp[p].x <= X&&vTemp[p].y >= 0 && vTemp[p].y <= Y)
								{
									int label = labels.at<int>(vTemp[p]);
									if (label != 0)
									{
										labeled[label] = 255;
										break;
									}
								}
							}
						}
						trackEnd = (!found);
					} while (!trackEnd);
				}
			}
			//去掉已标记处理的
			cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
				for (int y = range.start; y < range.end; y++)
				{
					for (int x = 0; x < X; x++)
					{
						int label = ((int *)labels.data)[(x)+(y)*labels.cols];
						CV_Assert(0 <= label && label <= nccomps);
						if (labeled[label])
						{
							((int *)(labels.data))[(x)+(y)*X] = 0;
						}
					}
				}
			});
			image = labels > 0;
			//判断是否存在未追踪单个料
			bExistSingle = (cv::countNonZero(image) == 0);
		} while (!bExistSingle);
		//拷贝计数
		binary = lb4Count.clone();
		//释放资源
		delete[] ucpTrackLabel;
		ucpTrackLabel = NULL;
	}
	//方形托盘
	else if (strcmp(ccSubType, "IP_SQUARE_PARTS") == 0)
	{

	}
	//普通算法不做其他处理
	else
	{
		//二值化
		cv::threshold(srcPrev, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
		cv::morphologyEx(binary, binary, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(75, 75)));
		//计算直方图
		int hist[256];
		for (int y = 0; y < 256; y++) hist[y] = 0;
		for (int y = 0; y < Y; y++)
		{
			uchar *uPtr = srcPrev.data + y * X;
			for (int x = 0; x < srcPrev.cols; x++, uPtr++)
			{
				if ((binary.data)[(x)+(y)*X] == 255)
				{
					hist[*uPtr]++;
				}
			}
		}
		cv::threshold(srcPrev, binary, Otsu(hist), 255, cv::THRESH_BINARY);
		//粗略计数
		cv::Mat labels, stats, centroids;
		int numObj = cv::connectedComponentsWithStats(binary, labels, stats, centroids);
		//坐标图
		binary = cv::Scalar(0);
		//画图
		double *dpCent = (double *)centroids.data;
		for (int j = 1; j < numObj; j++)
		{
			binary.at<uchar>(cv::Point(cvRound((float)dpCent[(0) + (j) * 2]), cvRound((float)dpCent[(1) + (j) * 2]))) = 255;
		}
	}
	//计数
	std::vector<cv::Point> vLocations;
	cv::findNonZero(binary, vLocations);
	for (int c = 0; c < vLocations.size(); c++)
	{
		cv::circle(cc, vLocations[c], 1, cv::Scalar(0, 255, 0, 255), 1);
	}
	std::string trayNum = std::to_string(vLocations.size());
	//输出结果
	*lpszNumObj = (char *)CoTaskMemAlloc(trayNum.size());
	if (NULL != lpszNumObj)
	{
		strcpy(*lpszNumObj, trayNum.c_str());
	}
	//获取当前运行目录
	char buf[128];
	_getcwd(buf, sizeof(buf));
	//
	std::string filePath(buf);
	filePath += "\\ResOut";
	if (_access(filePath.c_str(), 0) == -1)
		_mkdir(filePath.c_str());//不存在则创建
	//格式化文件名
	char file[256];
	sprintf_s(file, "%s\\%s-Mark.png", filePath.c_str(), fileName);
	cv::imwrite(file, cc);
	return FUNC_OK;
}

int eyemTrackFeature(EyemImage tpRefImg, EyemImage tpNextImg)
{
	//cv::Mat refImg(tpRefImg.iHeight, tpRefImg.iWidth,
	//	MAKETYPE(tpRefImg.iDepth, tpRefImg.iChannels), tpRefImg.vpImage);

	//cv::Mat nextImg(tpNextImg.iHeight, tpNextImg.iWidth,
	//	MAKETYPE(tpNextImg.iDepth, tpNextImg.iChannels), tpNextImg.vpImage);

	cv::VideoCapture cap;
	cap.open("D:\\插件完成检测\\视频\\cap5.mp4");

	if (!cap.isOpened())
		return FUNC_CANNOT_CALC;

	int totalFrmNum = cap.get(cv::CAP_PROP_FRAME_COUNT);

	//cv::namedWindow("eyemLib", cv::WINDOW_AUTOSIZE);

	cv::Mat refImg, nextImg;

	cap >> refImg;
	cv::cvtColor(refImg, refImg, cv::COLOR_BGR2GRAY);



	int nFrmNum = 0;
	do
	{
		clock_t begin = clock();

		cap >> nextImg;

		if (nextImg.empty())
			break;

		cv::cvtColor(nextImg, nextImg, cv::COLOR_BGR2GRAY);

		nFrmNum++;

		cv::Mat dst;
		cv::absdiff(nextImg, refImg, dst);

		cv::Mat binary;
		cv::threshold(dst, binary, 35, 255, cv::THRESH_BINARY);

		cv::Mat labels, stats, centroids;
		int nccomps = cv::connectedComponentsWithStats(binary, labels, stats, centroids);

		if (nFrmNum == 60)
			break;

		std::cout << "TimeCost:" << ((double)clock() - (double)begin) / CLOCKS_PER_SEC * 1000 << std::endl;

		//if (!dst.empty())
		//{
		//	cv::imshow("eyemLib", binary);
		//	cv::waitKey(10);
		//}
	} while (true);



	cv::waitKey(0);
	return FUNC_OK;
}