#ifdef _WIN32
#include <io.h>
#include <Windows.h>
#elif __linux__
#include <sys/stat.h>
#endif

#include <fstream>
#include "eyemMisc.h"

#pragma region 一些参数计算公式
/* 弦长计算公式
已知半径R。设该弦长所对的圆心角为φ，弦长为C，C=2Rsin(φ/2).
*/
#pragma endregion

#pragma region 内部使用的函数

/** 计算端点坐标
img			输入图像
*/
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);
}

/** 判断坐标是否在矩形中
_Rect		输入矩形
pt			输入坐标
*/
static inline bool isInRect(std::vector<cv::Point2f> _Rect, cv::Point pt)
{
	return cv::pointPolygonTest(_Rect, pt, false) > 0;
}

/** 计算矩形内坐标
_vRect		输入矩形
vPoints		输出坐标
*/
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));
			}
		}
	}
}

/** 计算旋转矩形
pt			输入坐标
t			输入角度
length		输入长度
width		输入宽度
pts			输出坐标
*/
static void calcRotateRect(cv::Point2f pt, float t, float length, float width, cv::Point2f *pts)
{
	float b = (float)cos(t*PI / 180.)*0.5f;
	float a = (float)sin(t*PI / 180.)*0.5f;

	pts[0].x = (float)(pt.x - a*length * 2 - b*width * 4);
	pts[0].y = (float)(pt.y + b*length * 2 - a*width * 4);
	pts[1].x = (float)(pt.x + a*length * 2 - b*width * 4);
	pts[1].y = (float)(pt.y - b*length * 2 - a*width * 4);
	pts[2].x = (float)(2 * pt.x - pts[0].x);
	pts[2].y = (float)(2 * pt.y - pts[0].y);
	pts[3].x = (float)(2 * pt.x - pts[1].x);
	pts[3].y = (float)(2 * pt.y - pts[1].y);
}

/** 获取旋转后的模板
_tplMat		输入图像
t			输入角度
val			填充内容
*/
static cv::Mat getTplMat(cv::Mat &tplMat, double t, int val)
{
	const int tplH = tplMat.rows, tplW = tplMat.cols;

	int width = cvRound((double)tplH * abs(sin(t * CV_PI / 180.)) + (double)tplW * abs(cos(t * CV_PI / 180.)));

	int height = cvRound(ceil((double)tplW * abs(sin(t * CV_PI / 180.)) + (double)tplH * abs(cos(t * CV_PI / 180.))));

	cv::Mat matx23f(2, 3, CV_64F);
	matx23f = cv::getRotationMatrix2D(cv::Point2f((float)tplW / 2.0f - 0.5f, (float)tplH / 2.0f - 0.5f), t, 1.0);

	//由于旋转产生的偏移
	matx23f.ptr<double>(0)[2] += (float)(width - tplW) / 2.0;
	matx23f.ptr<double>(1)[2] += (float)(height - tplH) / 2.0;

	//旋转
	cv::Mat tplMatD;
	cv::warpAffine(tplMat, tplMatD, matx23f, cv::Size((int)width, (int)height), cv::INTER_LINEAR, cv::BORDER_CONSTANT, val);

	return tplMatD;
}

/** 获取旋转后的图像
trackMat	输入图像
t			输入角度
val			填充内容
matx		转换矩阵
*/
static cv::Mat getTrackMat(cv::Mat &trackMat, double t, int val, float *matx)
{
	const int tckH = trackMat.rows, tckW = trackMat.cols;

	int tckdW = cvRound((double)tckH * abs(sin(t * CV_PI / 180.)) + (double)tckW * abs(cos(t * CV_PI / 180.)));

	int tckdH = cvRound(ceil((double)tckW * abs(sin(t * CV_PI / 180.)) + (double)tckH * abs(cos(t * CV_PI / 180.))));

	//创建矩阵
	cv::Mat matx23f(2, 3, CV_64F);
	matx23f = cv::getRotationMatrix2D(cv::Point2f((float)tckW / 2.0f - 0.5f, (float)tckH / 2.0f - 0.5f), t, 1.0);

	//由于旋转产生的偏移
	matx23f.ptr<double>(0)[2] += (float)(tckdW - tckW) / 2.0;
	matx23f.ptr<double>(1)[2] += (float)(tckdH - tckH) / 2.0;

	//输出矩阵
	matx[0] = (float)matx23f.ptr<double>(0)[0]; matx[1] = (float)matx23f.ptr<double>(0)[1]; matx[2] = (float)matx23f.ptr<double>(0)[2];
	matx[3] = (float)matx23f.ptr<double>(1)[0]; matx[4] = (float)matx23f.ptr<double>(1)[1]; matx[5] = (float)matx23f.ptr<double>(1)[2];

	//仿射变换
	cv::Mat tplMatD;
	cv::warpAffine(trackMat, tplMatD, matx23f, cv::Size(tckdW, tckdH), cv::INTER_LINEAR, cv::BORDER_CONSTANT, cv::Scalar(val));

	return tplMatD;
}

/** 模板追踪匹配
image		输入图像
tplMat		输入模板
t			方位角
trackWidth	扩充宽度
pts			矩形顶点
val			填充像素
bFinal		是否进行精确位置定位
maxVal		输出最大匹配分数
maxLoc		输出最大匹配坐标
mask		掩膜
*/
static bool findTrackModel(cv::Mat& image, cv::Mat &tplMat, double t, double trackWidth, cv::Point2f *pts, int val, bool bFinal, double &maxVal, cv::Point2f &maxLoc, cv::InputArray mask = cv::noArray())
{
	//图像尺寸
	int X = image.cols, Y = image.rows;

	//旋转矩形
	cv::RotatedRect r(pts[0], pts[1], pts[2]);

	//待匹配图像
	cv::Rect rr(cv::Point2i(cv::max(r.boundingRect().x - cvRound(trackWidth), 0), \
		cv::max(r.boundingRect().y - cvRound(trackWidth), 0)), \
		cv::Point2i(cv::min(r.boundingRect().x + r.boundingRect().width + cvRound(trackWidth), X), \
			cv::min(r.boundingRect().y + r.boundingRect().height + cvRound(trackWidth), Y)));

	float matx[6];
	cv::Mat trackMat = getTrackMat(image(rr&cv::Rect(0, 0, X, Y)).clone(), -t, val, matx);

	if (trackMat.cols <= (tplMat.cols - 1) || trackMat.rows <= (tplMat.rows - 1))
		return true;

	const int icvTemplateMatchModes[2] = { cv::TM_SQDIFF_NORMED,cv::TM_CCOEFF_NORMED };

	//计算匹配位置
	std::vector<cv::Mat> tplResults(6);
	cv::parallel_for_(cv::Range(0, 2), [&](const cv::Range& range)->void {
		for (int m = range.start; m < range.end; m++)
		{
			cv::Mat tplResult;
			cv::matchTemplate(trackMat, tplMat, tplResult, icvTemplateMatchModes[m]);

			tplResults[icvTemplateMatchModes[m]] = tplResult;
		}
	});

	//tbb::parallel_for(tbb::blocked_range<int>(0, 2), [&](tbb::blocked_range<int>& range) {
	//	for (int m = range.begin(); m < range.end(); m++)
	//	{
	//		cv::Mat tplResult;
	//		cv::matchTemplate(trackMats[m], tplMats[m], tplResult, icvTemplateMatchModes[m]);

	//		tplResults[icvTemplateMatchModes[m]] = tplResult;
	//	}
	//});

	cv::Mat tplResult0 = tplResults[5] - tplResults[1];

	//计算极值坐标
	cv::Point maxyyuloc;
	cv::minMaxLoc(tplResult0, NULL, &maxVal, NULL, &maxyyuloc);

	//偏移到中心
	maxyyuloc += cv::Point(tplMat.cols / 2, tplMat.rows / 2);

	//结果坐标限制在理论范围内
	if (bFinal)
	{
		//重新确定位置
		cv::Rect rLimit(cv::Point((trackMat.cols - tplMat.cols) / 2, (trackMat.rows - tplMat.rows) / 2), tplMat.size());

		//判断区域内有效面积所占比例
		if ((float)cv::countNonZero(getTplMat(mask.getMat()(rr&cv::Rect(0, 0, X, Y)), -t, 0)(rLimit)) / (float)rLimit.area() < 0.18) {
			//料盘结束
			return true;
		}

		if (!rLimit.contains(maxyyuloc))
		{
			//可能偏离位置,重新确定位置
			do
			{
				maxyyuloc -= cv::Point(tplMat.cols / 2, tplMat.rows / 2);

				tplResult0.ptr<float>(maxyyuloc.y)[maxyyuloc.x] = -1.0;

				cv::minMaxLoc(tplResult0, NULL, &maxVal, NULL, &maxyyuloc);

				maxyyuloc += cv::Point(tplMat.cols / 2, tplMat.rows / 2);

			} while (!rLimit.contains(maxyyuloc));
		}
	}

	//计算旋转前的坐标（即匹配的最终坐标）
	maxLoc.x = (float)rr.x + (((float)maxyyuloc.x - matx[2])*matx[4] - ((float)maxyyuloc.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
	maxLoc.y = (float)rr.y + (((float)maxyyuloc.x - matx[2])*matx[3] - ((float)maxyyuloc.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

	return false;
}

/** 分割字符串
cStrText	输入文本
cStrDelim	输入分隔符
vStrs		输出分割后内容
*/
static void split(const std::string &cStrText, const std::string &cStrDelim, std::vector<std::string> &vStrs)
{
	char *cpStr = new char[strlen(cStrText.c_str()) + 1];
	strcpy(cpStr, cStrText.c_str());
	//分割
	char *token = NULL, *ptr = NULL;
	token = strtok_s(cpStr, cStrDelim.c_str(), &ptr);
	while (NULL != token)
	{
		vStrs.push_back(token);
		token = strtok_s(NULL, cStrDelim.c_str(), &ptr);
	}
	delete[] cpStr;
	cpStr = NULL;
}

/** 载入模板
trackMat	输入文件名
*/
static void loadTrackModel(const char *fileName, cv::OutputArray tplMat, cv::Point &pt, double &dMatchDeg, const char *callFunc = "")
{
	std::string logModule = std::string(callFunc) + "->";
	logModule += __func__;

	logModule += "(" + std::to_string(*(uint32_t *)(&std::this_thread::get_id())) + "):";

	struct stat _Stat;

	if (stat(fileName, &_Stat) != 0)
		return;

	//上锁
	logger.t(logModule + "上锁...");

	logger.t(logModule + "打开文件...");
	FILE *fps = NULL;
	fopen_s(&fps, fileName, "r");

	//判断文件是否打开
	if (NULL == fps)
		return;

	//获取文件大小
	const int _Size = (int)_Stat.st_size;

	//分配内存
	unsigned char *_Data = (unsigned char *)malloc(_Size);

	if (NULL == _Data)
		return;

	//初始化
	memset(_Data, 0, _Size);

	//读取数据
	logger.t(logModule + "读取二进制数据...");
	fread(_Data, sizeof(uint8_t), _Size, fps);

	//关闭文件
	logger.t(logModule + "关闭文件...");
	fclose(fps);

	//解锁
	logger.t(logModule + "解锁...");

	//获取图像数据大小
	logger.t(logModule + "拷贝头数据...");
	unsigned char _SizeData[8];
	memcpy(_SizeData, _Data, 8);

	//有效信息长度
	const int valSize = std::atoi((const char *)_SizeData);

	//文件信息
	const int tplSize = _Size - valSize - 8;

	//拷贝文件信息
	logger.t(logModule + "拷贝文件信息...");
	char *tplInfo = new char[tplSize];
	memcpy(tplInfo, _Data + valSize + 8, tplSize);

	//获取文件信息
	logger.t(logModule + "分割字符串...");
	std::string line(tplInfo);
	std::vector<std::string> hints;
	split(line, ",", hints);

	//宽，高，坐标，匹配度
	logger.t(logModule + "文件信息类型转换...");
	int X = std::atoi(hints[2].c_str()), Y = std::atoi(hints[3].c_str());

	dMatchDeg = std::atof(hints[4].substr(0, 4).c_str()); pt = cv::Point(std::atoi(hints[0].c_str()), std::atoi(hints[1].c_str()));

	//创建图像文件
	logger.t(logModule + "创建模板图像...");
	tplMat.create(Y, X, CV_8UC1, -1, true);

	//拷贝数据
	logger.t(logModule + "拷贝图像数据...");
	cv::Mat _tplMat = tplMat.getMat();
	memcpy(_tplMat.data, _Data + 8, valSize);

	//释放内存
	logger.t(logModule + "释放内存...");
	delete[] tplInfo;
	tplInfo = NULL;

	//释放文件内存
	free(_Data);
	_Data = NULL;
}


/** 十进制转二进制数
d			输入十进制数字
*/
static std::string DtoB(int d)
{
	return "";
}

/** 获取文件夹内所有文件
filePath	输入文件夹
fileNames	输出文件
*/
static void getFiles(std::string filePath, std::vector<std::string>& fileNames)
{
	//文件句柄  
	intptr_t  hFile = 0;
	//文件信息  
	struct _finddata_t fileinfo;
	std::string p;
	if ((hFile = _findfirst(p.assign(filePath).append("\\*").c_str(), &fileinfo)) != -1)
	{
		do
		{
			//如果是目录,迭代之,如果不是,加入列表  
			if ((fileinfo.attrib &  _A_SUBDIR)) {
				if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
					getFiles(p.assign(filePath).append("\\").append(fileinfo.name), fileNames);
			}
			else {
				fileNames.push_back(p.assign(filePath).append("\\").append(fileinfo.name));
			}
		} while (_findnext(hFile, &fileinfo) == 0);
		_findclose(hFile);
	}
}

/** 计算Otsu阈值
hist		输入直方图
*/
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;
}

/** 计算Otsu阈值
_src		输入图像
*/
static double getThreshVal_Otsu_8u(const cv::Mat& _src)
{
	cv::Size size = _src.size();
	int step = (int)_src.step;
	if (_src.isContinuous())
	{
		size.width *= size.height;
		size.height = 1;
		step = size.width;
	}

#ifdef HAVE_IPP
	unsigned char thresh = 0;
	CV_IPP_RUN_FAST(ipp_getThreshVal_Otsu_8u(_src.ptr(), step, size, thresh), thresh);
#endif

	const int N = 256;
	int i, j, h[N] = { 0 };
#if CV_ENABLE_UNROLLED
	int h_unrolled[3][N] = {};
#endif
	for (i = 0; i < size.height; i++)
	{
		const uchar* src = _src.ptr() + step*i;
		j = 0;
#if CV_ENABLE_UNROLLED
		for (; j <= size.width - 4; j += 4)
		{
			int v0 = src[j], v1 = src[j + 1];
			h[v0]++; h_unrolled[0][v1]++;
			v0 = src[j + 2]; v1 = src[j + 3];
			h_unrolled[1][v0]++; h_unrolled[2][v1]++;
		}
#endif
		for (; j < size.width; j++)
			h[src[j]]++;
	}

	double mu = 0, scale = 1. / (size.width*size.height);
	for (i = 0; i < N; i++)
	{
#if CV_ENABLE_UNROLLED
		h[i] += h_unrolled[0][i] + h_unrolled[1][i] + h_unrolled[2][i];
#endif
		mu += i*(double)h[i];
	}

	mu *= scale;
	double mu1 = 0, q1 = 0;
	double max_sigma = 0, max_val = 0;

	for (i = 0; i < N; i++)
	{
		double p_i, q2, mu2, sigma;

		p_i = h[i] * scale;
		mu1 *= q1;
		q1 += p_i;
		q2 = 1. - q1;

		if (std::min(q1, q2) < FLT_EPSILON || std::max(q1, q2) > 1. - FLT_EPSILON)
			continue;

		mu1 = (mu1 + i*p_i) / q1;
		mu2 = (mu - q1*mu1) / q2;
		sigma = q1*q2*(mu1 - mu2)*(mu1 - mu2);
		if (sigma > max_sigma)
		{
			max_sigma = sigma;
			max_val = i;
		}
	}

	return max_val;
}

/** 计算元件尺寸
srcPrev		输入图像
mask		输入掩膜
partSize	输出元件尺寸
*/
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;
}

#pragma endregion

int eyemCountObject(EyemImage tpImage, EyemRect tpRoi, const char *fileName, int *ipReelNum, EyemImage *tpDstImg)
{
	cv::Mat src = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();
	if (src.empty()) {
		return FUNC_IMAGE_NOT_EXIST;
	}
	//转单通道
	if (src.channels() != 1)
		cv::cvtColor(src, src, cv::COLOR_BGR2GRAY);

	//跳过执行
	if (killProcessID == 0) {
		logger.t("eyemCountObjectIrregularPartsE 初始阶段被跳过执行...");
		return FUNC_CANNOT_CALC;
	}

	//图像裁剪
	src = src(cv::Rect(tpRoi.iXs, tpRoi.iYs, tpRoi.iWidth, tpRoi.iHeight)).clone();

	//image size
	int X = src.cols, Y = src.rows;

	//去除局部量斑影响（默认亮斑尺寸不会大于15个像素）
	cv::Mat srcTmp;
	cv::morphologyEx(src, srcTmp, cv::MORPH_ERODE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(15, 15)));

	//去除黑斑影响
	int m = cvRound(cv::mean(src)[0]);
	srcTmp.forEach<uint16_t>([&](uint16_t& pixel, const int *pos)->void {
		pixel = pixel == 0 ? m : pixel;
	});

	//image enhancement
	double min, max;
	cv::Point maxId;
	cv::minMaxLoc(srcTmp, &min, &max, NULL, &maxId);
	src.convertTo(src, CV_64FC1);

	src -= min;
	src /= (max - min);
	src *= 65535;
	src.convertTo(src, CV_16UC1);

	cv::Mat src8U;
	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 = "无料,";
		for (int i = 0; i < 4; i++) {
			ipReelNum[i] = 0;
		}
		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
			{
				//跳过执行
				if (killProcessID == 0) {
					logger.t("eyemCountObjectIrregularPartsE 点料阶段被跳过执行...");
					break;
				}

				//不随机挑选起点(考虑换成面积最小的那个)
				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;
										}
									}
								}
							}

							//跳过执行
							if (killProcessID == 0) {
								logger.t("eyemCountObjectIrregularPartsE 追踪阶段被跳过执行...");
								found = false;
							}

							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;
										}
									}
								}
							}

							//跳过执行
							if (killProcessID == 0) {
								logger.t("eyemCountObjectIrregularPartsE 追踪阶段被跳过执行...");
								found = false;
							}

							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 SizeConst = 4;
	//<输出计数结果标记图像
	{
		for (int i = 0; i < SizeConst; i++) {
			ipReelNum[i] = trayNum[i];
		}

		tpDstImg->iWidth = cc.cols; tpDstImg->iHeight = cc.rows; tpDstImg->iDepth = cc.depth(); tpDstImg->iChannels = cc.channels();

		//内存尺寸
		int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);

		//分配内存
		tpDstImg->vpImage = (uint8_t *)malloc(_Size);
		if (NULL == tpDstImg->vpImage)
			return FUNC_NOT_ENOUGH_MEM;
		memset(tpDstImg->vpImage, 0, _Size);

		//拷贝数据
		memcpy(tpDstImg->vpImage, cc.data, _Size);
	}
	return FUNC_OK;
}

int eyemCountObjectIrregularParts(EyemImage tpImage, EyemRect tpRoi, const char *fileName, const char * ccSubType, int *ipReelNum, EyemImage *tpDstImg)
{
	cv::Mat src = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();
	if (src.empty()) {
		return FUNC_IMAGE_NOT_EXIST;
	}
	//转单通道图像
	if (src.channels() != 1)
		cv::cvtColor(src, src, cv::COLOR_BGR2GRAY);
	//跳过执行
	if (killProcessID == 0) {
		logger.t("eyemCountObjectIrregularPartsE 初始阶段被跳过执行...");
		return FUNC_CANNOT_CALC;
	}
	//图像裁剪
	src = src(cv::Rect(tpRoi.iXs, tpRoi.iYs, tpRoi.iWidth, tpRoi.iHeight)).clone();

	//图像尺寸
	int X = src.cols, Y = src.rows;

	//去除局部亮斑与黑斑影响（默认亮斑尺寸不会大于15个像素）
	cv::Mat srcTmp, srcTmp2;
	cv::morphologyEx(src, srcTmp, cv::MORPH_ERODE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(15, 15)));

	//去除黑斑影响
	int m = cvRound(cv::mean(src)[0]);
	srcTmp.forEach<uint16_t>([&](uint16_t& pixel, const int *pos)->void {
		pixel = pixel == 0 ? m : pixel;
	});
	//图像增强
	double min, max;
	cv::minMaxLoc(srcTmp, &min, &max);

	src.convertTo(src, CV_64FC1);
	src -= min;
	src /= (max - min);
	src *= 65535;
	src.convertTo(src, CV_16UC1);

	//转8位灰度图
	cv::Mat src8U;
	src.convertTo(src8U, CV_8UC1, 1 / 255.);

	//测试用
	cv::Mat testmat = src8U.clone();
	//用于显示
	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::Mat srcMean;
		cv::blur(srcPrev, srcMean, cv::Size(7, 7));

		cv::Mat srcMinus;
		srcMinus = srcPrev - srcMean;

		//二值化
		cv::threshold(srcMinus, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
		//去掉<=1面积的干扰
		{
			cv::Mat labels, stats, centroids;
			int nccomps = cv::connectedComponentsWithStats(binary, labels, stats, centroids);
			//过滤连通域面积<=1的
			std::vector<uchar> colors(nccomps + 1, 0);
			for (int i = 1; i < nccomps; i++) {
				colors[i] = 255;
				if ((stats.ptr<int>(i)[cv::CC_STAT_AREA] <= 1))
				{
					colors[i] = 0;
				}
			}
			//过滤
			cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
				for (int y = range.start; y < range.end; y++)
				{
					uint8_t *ptrRow = binary.ptr<uint8_t>(y);
					for (int x = 0; x < X; x++)
					{
						int label = labels.ptr<int>(y)[x];
						CV_Assert(0 <= label && label <= nccomps);
						ptrRow[x] = colors[label];
					}
				}
			});
		}

		cv::morphologyEx(binary, binary, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3)));

		//分连通域进行自适应二值化
		{
			cv::Mat labels, stats, centroids;
			int nccomps = cv::connectedComponentsWithStats(binary, labels, stats, centroids);

			struct NccompsThresh
			{
				int ID;
				double T;
				NccompsThresh(int ID, double T) :ID(ID), T(T) {}
			};

			std::vector<NccompsThresh> nts;
			for (int n = 1; n < nccomps; n++) {
				cv::Rect rec(stats.ptr<int>(n)[cv::CC_STAT_LEFT] - 1, stats.ptr<int>(n)[cv::CC_STAT_TOP] - 1, \
					stats.ptr<int>(n)[cv::CC_STAT_WIDTH] + 2, stats.ptr<int>(n)[cv::CC_STAT_HEIGHT] + 2);

				cv::Mat maskID = labels(rec) == n;

				cv::Mat maskSrc = srcMinus(rec);

				double min, max;
				cv::minMaxLoc(maskSrc, &min, &max, NULL, NULL, maskID);

				nts.push_back(NccompsThresh(n, max*0.4));
			}

			//二值化
			cv::Mat loc(Y, X, CV_8UC1, cv::Scalar(0));
			for (int y = 1; y < Y - 1; y++)
			{
				uint8_t *ptrRow = loc.ptr<uint8_t>(y);
				for (int x = 1; x < X - 1; x++)
				{
					int label = labels.ptr<int>(y)[x];
					CV_Assert(0 <= label && label <= nccomps);
					if (label > 0) {
						ptrRow[x] = srcMinus.ptr<uint8_t>(y)[x] > nts[label - 1].T ? 255 : 0;
					}
				}
			}
			//去掉太长的干扰
			{
				cv::Mat labels, stats, centroids;
				int nccomps = cv::connectedComponentsWithStats(loc, labels, stats, centroids);
				//过滤连通域面积<=1的
				std::vector<uchar> colors(nccomps + 1, 0);
				for (int i = 1; i < nccomps; i++) {
					colors[i] = 255;
					if ((stats.ptr<int>(i)[cv::CC_STAT_WIDTH] > 9) || (stats.ptr<int>(i)[cv::CC_STAT_HEIGHT] > 9))
					{
						colors[i] = 0;
					}
				}
				//过滤
				cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
					for (int y = range.start; y < range.end; y++)
					{
						uint8_t *ptrRow = loc.ptr<uint8_t>(y);
						for (int x = 0; x < X; x++)
						{
							int label = labels.ptr<int>(y)[x];
							CV_Assert(0 <= label && label <= nccomps);
							ptrRow[x] = colors[label];
						}
					}
				});
			}
			binary = loc;
		}

		cv::Mat srcPrevEx; cv::Mat mask;
		cv::morphologyEx(srcPrev, srcPrevEx, cv::MORPH_TOPHAT, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3)));
		cv::threshold(srcPrevEx, mask, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
		binary &= mask;

		//定位料盘中心
		cv::Mat srcPrevLoc;
		cv::morphologyEx(binary, srcPrevLoc, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(13, 13)));

		cv::Mat image(Y, X, CV_8UC1, cv::Scalar(0));
		std::vector<std::vector<cv::Point>> contourAll;
		findContours(srcPrevLoc, contourAll, cv::noArray(), cv::RETR_TREE, cv::CHAIN_APPROX_NONE);
		for (int n = 0; n < contourAll.size(); n++) {
			cv::drawContours(image, contourAll, n, cv::Scalar(255), -1);
		}

		//寻找最大轮廓
		std::vector<cv::Point> contourMax; double contourMaxArea = 0; cv::Point2f center; float radius;
		contourMax = contourAll[0]; contourMaxArea = cv::contourArea(contourMax);
		for (int i = 1; i < contourAll.size(); i++)
		{
			double contourArea = cv::contourArea(contourAll[i]);
			if (contourArea > contourMaxArea)
			{
				contourMax = contourAll[i];
				contourMaxArea = contourArea;
			}
		}
		//去掉外部干扰
		cv::minEnclosingCircle(contourMax, center, radius);

		cv::Mat temp(Y, X, CV_8UC1, cv::Scalar(0));
		cv::circle(temp, center, cvRound(radius), cv::Scalar(255), -1);
		binary &= temp;

		image -= srcPrevLoc;

		cv::morphologyEx(image, image, cv::MORPH_OPEN, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(11, 11)));

		contourAll.resize(0);
		findContours(image, contourAll, cv::noArray(), cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

		if (contourAll.empty()) {
			return FUNC_CANNOT_CALC;
		}

		//寻找最大轮廓
		contourMax = contourAll[0]; contourMaxArea = cv::contourArea(contourMax);
		for (int i = 1; i < contourAll.size(); i++)
		{
			double contourArea = cv::contourArea(contourAll[i]);
			if (contourArea > contourMaxArea)
			{
				contourMax = contourAll[i];
				contourMaxArea = contourArea;
			}
		}

		cv::minEnclosingCircle(contourMax, center, radius);

		//去除内部干扰
		cv::circle(binary, center, cvRound(radius - 15), cv::Scalar(0), -1);

		//待处理区域
		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; std::vector<cv::Point> forfilter;
		for (int j = 1; j < numObj; j++)
		{
			cv::Point pt(cvRound(centroids.ptr<double_t>(j)[0]), cvRound(centroids.ptr<double_t>(j)[1]));
			forfilter.push_back(pt);
			binary.at<uchar>(pt) = 255;
		}
		//过滤
		cv::Mat filtermap(Y, X, CV_8UC1, cv::Scalar(0));
		for (int i = 0; i < forfilter.size(); i++)
		{
			cv::Rect rec = cv::Rect(forfilter[i].x - 25, forfilter[i].y - 25, 50, 50)&cv::Rect(0, 0, X, Y);
			cv::Mat filter = testmat(rec);
			cv::Mat mask = binary(rec);
			if (!(testmat.ptr<uint8_t>(forfilter[i].y)[forfilter[i].x] > cv::mean(filter, mask)[0] + 45)) {
				filtermap.at<uchar>(forfilter[i]) = 255;
				cv::circle(cc, forfilter[i], 1, cv::Scalar(0, 255, 0, 255), 1);
			}
		}
		binary = filtermap;
		//释放资源
		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.ptr<uint8_t>(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 FUNC_CANNOT_CALC;
		//统计元件面积
		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;

		//2021/08/26增加测试用
		cv::morphologyEx(image, image, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(45, 45)));
		//获取最大轮廓
		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);
		struct TracingAnchor
		{
			float Size;
			float Length, Height;
			cv::Point2f Anchor;
			cv::RotatedRect RBox;
			TracingAnchor(cv::Point2f Anchor, float Length, float Height, float Size, cv::RotatedRect RBox) :Anchor(Anchor), Length(Length), Height(Height), Size(Size), RBox(RBox) {}
			bool operator >(const TracingAnchor &te)const
			{
				return Size > te.Size;
			}
			bool operator <(const TracingAnchor &te)const
			{
				return Size < te.Size;
			}
		};
		std::vector<std::vector<cv::Point>> contourTracing;
		cv::findContours(image, contourTracing, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
		//所有追踪锚点
		std::vector<TracingAnchor> tracingAnchors;
		for (auto&contour : contourTracing) {
			cv::RotatedRect rbox = cv::minAreaRect(contour);
			if (cv::min(rbox.size.width, rbox.size.height) > 2.0f) {
				tracingAnchors.push_back(TracingAnchor(rbox.center, cv::max(rbox.size.width, rbox.size.height), cv::min(rbox.size.width, rbox.size.height), rbox.size.area(), rbox));
			}
		}
		//不存在独立元件
		if (tracingAnchors.empty()) {
			return FUNC_CANNOT_CALC;
		}
		//尺寸只计算一次
		std::sort(tracingAnchors.begin(), tracingAnchors.end(), std::greater<TracingAnchor>());
		//
		struct Track {
			int iLimit, iPartSize;
			double dMatchDeg = 0.0;
			cv::Point2f Pos;
			std::vector<cv::Point2f> Rect;

			Track() {};

			Track(int iLimit, int iPartSize, double dMatchDeg, cv::Point2f 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;
			}
			bool operator <(const Track &te)const
			{
				return dMatchDeg < te.dMatchDeg;
			}
		};
		//缩放比例
		float coeff = 1.0f;
		//填充值
		const int fillVal = 255 - backThresh;
		//元件尺寸
		const double taLength = tracingAnchors[tracingAnchors.size() / 2].Length; const double taHeight = tracingAnchors[tracingAnchors.size() / 2].Height;
		//元件灰度值
		double taMaxGray = 0.0;
		//标签图
		unsigned char *ucpTrackLabel = new unsigned char[Y*X]();
		cv::Mat trackMat(Y, X, CV_8UC1, ucpTrackLabel);
		//计数图像
		cv::Mat lbMat(Y, X, CV_8UC1, cv::Scalar(0));
		//定位图像
		cv::Mat srcPrevS, tplMat;//模板文件
		srcPrev.convertTo(srcPrevS, CV_32F);
		//随机打乱顺序（降低计算错误dChordL的可能性，也为了测试在起点信息不同时的稳定性）
		std::random_shuffle(tracingAnchors.begin(), tracingAnchors.end());
		//开始确定起点（现在是用圆轨迹来追踪，不排除用螺旋线轨迹来追踪）
		for (std::vector<TracingAnchor>::iterator itvx = tracingAnchors.begin(); itvx != tracingAnchors.end(); ++itvx) {
			//跳过执行
			if (killProcessID == 0) {
				logger.t("eyemCountObjectIrregularParts 点料阶段被跳过执行...");
				break;
			}
			//起始位置信息
			TracingAnchor ta = (*itvx);
			//起始位置坐标
			cv::Point2f startCenter(ta.Anchor.x, ta.Anchor.y);
			//最小外包矩形
			cv::Point2f _pts[4];
			ta.RBox.points(_pts);
			//已做标记(TODO:考虑增加判断哪些是起点哪些不是)
			if (trackMat.ptr<uint8_t>(cvRound(startCenter.y))[cvRound(startCenter.x)] == 255) {
				continue;
			}
			//获取模板图像(是否每次起点都计算模板，如果元件变形过大是否还会有用？)
			if (tplMat.empty())
			{
				float tDist = ta.Height / 2.0f;
				//理论范围扩展
				cv::Rect _rLimits = cv::Rect(cv::Point2i(cvRound((float)ta.RBox.boundingRect2f().tl().x - tDist),
					cvRound((float)ta.RBox.boundingRect2f().tl().y - tDist)), cv::Point2i(cvRound((float)ta.RBox.boundingRect2f().br().x + tDist),
						cvRound((float)ta.RBox.boundingRect2f().br().y + tDist))
				)&cv::Rect(0, 0, X, Y);

				//确定元件位置根据旋转后的位置确定（前提是料盘中心定位的准确）
				double t = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180.0 / PI;
				//计算旋转角度
				cv::Mat traceMat = srcPrev(_rLimits);
				//这里计算得出的模板不是很对
				float matx[6];
				tplMat = getTrackMat(traceMat, t + 90.0, 0, matx);
				//变换后的坐标
				cv::Point2f __pts[4];
				for (int j = 0; j < 4; j++)
				{
					__pts[j].x = matx[0] * (_pts[j].x - (float)_rLimits.x) + matx[1] * (_pts[j].y - (float)_rLimits.y) + matx[2];
					__pts[j].y = matx[3] * (_pts[j].x - (float)_rLimits.x) + matx[4] * (_pts[j].y - (float)_rLimits.y) + matx[5];
				}
				cv::Point2f __ptsc((__pts[0].x + __pts[1].x + __pts[2].x + __pts[3].x) / 4.0f, (__pts[0].y + __pts[1].y + __pts[2].y + __pts[3].y) / 4.0f);
				//确定各顶点方位
				struct DIR {
					int i = -1;
					cv::Point2f pt;
					DIR() {};

					DIR(int i, cv::Point2f pt) :i(i), pt(pt) {};
				};
				auto _dir_l = std::vector<DIR>(); auto _dir_r = std::vector<DIR>();
				for (int j = 0; j < 4; j++)
				{
					if (__pts[j].x < __ptsc.x) {
						_dir_l.push_back(DIR(j, __pts[j]));
					}
					else {
						_dir_r.push_back(DIR(j, __pts[j]));
					}
				}
				//重新选点计算模板
				if (_dir_l.size() != _dir_r.size()) {
					continue;
				}
				//确定顶点方向
				cv::Point2f p0, p1, p2, p3;
				if (_dir_l[0].pt.y < _dir_l[1].pt.y) {
					p0 = _pts[_dir_l[0].i];
					p1 = _pts[_dir_l[1].i];
				}
				else {
					p0 = _pts[_dir_l[1].i];
					p1 = _pts[_dir_l[0].i];
				}

				if (_dir_r[0].pt.y > _dir_r[1].pt.y) {
					p2 = _pts[_dir_r[0].i];
					p3 = _pts[_dir_r[1].i];
				}
				else {
					p2 = _pts[_dir_r[1].i];
					p3 = _pts[_dir_r[0].i];
				}
				//计算精确角度
				cv::Point2f p01((p0.x + p1.x) / 2.0f, (p0.y + p1.y) / 2.0f), p23((p2.x + p3.x) / 2.0f, (p2.y + p3.y) / 2.0f);

				double realT = atan2((double)p23.y - (double)p01.y, (double)p23.x - (double)p01.x) * 180.0 / PI;
				cv::Mat realTplMat = getTrackMat(traceMat, realT, 0, matx);

				cv::Point2f __mpts[4];
				for (int j = 0; j < 4; j++)
				{
					__mpts[j].x = matx[0] * (_pts[j].x - (float)_rLimits.x) + matx[1] * (_pts[j].y - (float)_rLimits.y) + matx[2];
					__mpts[j].y = matx[3] * (_pts[j].x - (float)_rLimits.x) + matx[4] * (_pts[j].y - (float)_rLimits.y) + matx[5];
				}

				cv::Rect _rr(cvFloor(std::min(std::min(std::min(__mpts[0].x, __mpts[1].x), __mpts[2].x), __mpts[3].x)),
					cvFloor(std::min(std::min(std::min(__mpts[0].y, __mpts[1].y), __mpts[2].y), __mpts[3].y)),
					cvCeil(std::max(std::max(std::max(__mpts[0].x, __mpts[1].x), __mpts[2].x), __mpts[3].x)),
					cvCeil(std::max(std::max(std::max(__mpts[0].y, __mpts[1].y), __mpts[2].y), __mpts[3].y))); _rr.width -= _rr.x - 1; _rr.height -= _rr.y - 1;

				//最终模板
				tplMat = realTplMat(_rr).clone();
				//缩放比例
				if (MIN(tplMat.size().width, tplMat.size().height) < 12.0) {
					coeff = 2.0f;
				}
				//最大值
				cv::minMaxLoc(tplMat, NULL, &taMaxGray);
			}
			//标记为已追踪过
			std::vector<cv::Point> vT = { cv::Point(_pts[0]),cv::Point(_pts[1]) ,cv::Point(_pts[2]) ,cv::Point(_pts[3]) };
			cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
			//标记计数
			lbMat.ptr<uint8_t>(cvRound(startCenter.y))[cvRound(startCenter.x)] = 255;
			//标记当前位置
			cv::drawMarker(cc, cv::Point(startCenter), cv::Scalar(0, 255, 0, 255), cv::MARKER_DIAMOND, 5);
			//扫描步长
			const double dMinorStep = 0.1;
			//追踪长宽
			const double trackLength = taLength / 2.0, trackWidth = taHeight / 4.0;//是否用较小尺寸的窗口
			//起始扫描角度
			const double startAngle = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180.0 / PI;
			//起始扫描半径
			const double startRadius = cv::norm(startCenter - reelCenter);
			//偏移角度（元件尺寸）
			const double dOffset = (2.0 * asin(2.0 * trackLength / (2.0 * startRadius))) * 180.0 / PI;
			//扫描角度（默认15度范围内存在元件）
			const double dScanRange = 15.0;
			//追踪元件间距(弦长，可以尽量避免因个别器件偏离导致的追踪中断)
			double dChordL = .0;
			for (double t = startAngle + dOffset / 1.5; t < startAngle + dScanRange; t += dMinorStep)
			{
				float x = float(reelCenter.x + startRadius*cos(t*c));
				float y = float(reelCenter.y + startRadius*sin(t*c));
				//防止超出图像范围
				if (cvRound(x) < 0 || (cvRound(x) > X - 1) || cvRound(y) < 0 || (cvRound(y) > Y - 1)) {
					break;
				}
				//确定是否是下一个元件
				if (trackMat.ptr<uint8_t>(cvRound(y))[cvRound(x)] == 255) {
					continue;
				}
				//初次确定元件间距
				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)));
#ifdef _DEBUG
				cv::line(cc, p1, p2, cv::Scalar(0, 215, 255, 255), 1);
#endif
				cv::LineIterator it(binary, p1, p2, 4);
				for (int n = 0; n < it.count; n++, ++it)
				{
					if (binary.ptr<uint8_t>(it.pos().y)[it.pos().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 > 2.1)
					break;
			}
			//没确定出元件间距一般为结尾或单个元件，继续从下一个起点计算弦长并开始追踪
			if (dChordL <= 2.1) {
				continue;
			}
			//顺时针(是否并行取决于在windows下运行还是树莓派上)
			{
				//追踪中心
				cv::Point2f trackCenter = cv::Point2f(startCenter.x, startCenter.y);
				//追踪角度、半径
				double trackAngle = startAngle, trackRadius = startRadius;
				//元件本身所占角度
				double trackOffset = dOffset;
				//元件间间距
				double partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
				//开始追踪
				bool trackEnd = true;
				do
				{
					bool found = true; bool trayEnd = false;
					std::vector<Track> vParts;
					for (double t = trackAngle + (trackOffset + partDist - trackOffset / 12.0); t < trackAngle + (trackOffset + partDist - trackOffset / 12.0) + trackOffset / 6.0; t += dMinorStep)
					{
						cv::Point2f predicPos;
						predicPos.x = reelCenter.x + (float)trackRadius*(float)cos((trackAngle + (trackOffset + partDist))*c);
						predicPos.y = reelCenter.y + (float)trackRadius*(float)sin((trackAngle + (trackOffset + partDist))*c);
						//如果追踪到图像外则追踪终止
						if (cvRound(predicPos.x) < 0 || (cvRound(predicPos.x) > X - 1) || cvRound(predicPos.y) < 0 || (cvRound(predicPos.y) > Y - 1)) {
							trayEnd = true;
							break;
						}
						//感兴趣区域(向外扩展了一个元件,防止中心定位出现偏差或者料盘本身变形导致的偏差)
						cv::Point2f predictBox[4];
						calcRotateRect(predicPos, (float)(trackAngle + (trackOffset + partDist)), (float)trackLength + (float)trackLength, (float)trackWidth + (float)trackWidth, predictBox);

						cv::RotatedRect r(predictBox[0], predictBox[1], predictBox[2]);
						cv::Rect rLimits = r.boundingRect()&cv::Rect(0, 0, X, Y);

						//获取感兴趣区域
						float matx[6];
						cv::Mat traceMat = getTrackMat(srcPrevS(rLimits).clone()
							, (trackAngle + (trackOffset + partDist)) + 90.0, fillVal, matx);

						//计算原图中的点在旋转后的位置(即在traceMat中的精确位置)
						cv::Point2f predictBoxR[4];
						for (int j = 0; j < 4; j++)
						{
							predictBoxR[j].x = matx[0] * (predictBox[j].x - (float)rLimits.x) + matx[1] * (predictBox[j].y - (float)rLimits.y) + matx[2];
							predictBoxR[j].y = matx[3] * (predictBox[j].x - (float)rLimits.x) + matx[4] * (predictBox[j].y - (float)rLimits.y) + matx[5];
						}
						//中点
						cv::Point2f predicPosR((predictBoxR[0].x + predictBoxR[1].x + predictBoxR[2].x + predictBoxR[3].x) / 4.0f,
							(predictBoxR[0].y + predictBoxR[1].y + predictBoxR[2].y + predictBoxR[3].y) / 4.0f);

						//理论区域
						cv::Rect tRec = cv::Rect(cv::Point(cvRound((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f),
							cvRound((predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f)),
							cv::Size(cvRound(trackLength*2.0), cvRound(trackWidth*4.0)))
							&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

						//高精度理论区域
						cv::Rect_<float> tRecF = cv::Rect_<float>(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f,
							(predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f),
							cv::Size2f((float)trackLength*2.0f, (float)trackWidth*4.0f))
							&cv::Rect_<float>(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

						//理论区域向外扩展(即predictBox范围)
						cv::Rect rr = cv::Rect(cv::Point(cvRound((double)predicPosR.x - trackLength*2.0),
							cvRound((double)predicPosR.y - trackWidth*4.0)), cv::Size(cvRound(trackLength*2.0*2.0),
								cvRound(trackWidth*4.0*2.0)))&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

						cv::Rect_<float> rrf = cv::Rect2f(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*4.0f) / 2.0f,
							(predicPosR.y*2.0f - (float)trackWidth*8.0f) / 2.0f), cv::Size2f((float)trackLength*4.0f, (float)trackWidth*8.0f))
							&cv::Rect2f(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

						//元件尺寸太小放大N倍处理，这样坐标会精细些,考虑元件的80%尺寸作为kernel，防止元件尺寸变化太大
						cv::Mat kernel = cv::Mat::ones(cv::Size(cv::max(cvRound((float)(trackLength*2.0) * coeff),
							cvRound((float)(trackWidth*4.0) * coeff)), cv::min(cvRound((float)(trackLength*2.0) * coeff),
								cvRound((float)(trackWidth*4.0) * coeff))), CV_32FC1);

						cv::Mat _traceMat = traceMat.clone();
						//放大
						if (coeff > 1.0f) {
							cv::resize(_traceMat, _traceMat, cv::Size(cvRound(traceMat.size().width * coeff), cvRound(traceMat.size().height * coeff)));
						}

						//计算最大值(当_traceMat尺寸小于kernel会报错)
						cv::Mat dst;
						cv::filter2D(_traceMat, dst, CV_32F, kernel);

						//归一化
						cv::Mat mmRescaling;
						cv::normalize(dst, mmRescaling, 1.0, 0.0, cv::NORM_MINMAX);

						//模板匹配做辅助判断,为了尽量避免定位出错
						cv::Mat _tplMat;
						tplMat.convertTo(_tplMat, CV_32FC1);
						if (coeff > 1.0f) {
							cv::resize(_tplMat, _tplMat, cv::Size(), coeff, coeff);
						}
						//防止报错
						if (_tplMat.cols > _traceMat.cols || _tplMat.rows > _traceMat.rows) {
							return FUNC_CANNOT_CALC;
						}
						//考虑并行计算两个模板结果
						cv::Mat tplResult0;
						cv::matchTemplate(_traceMat, _tplMat, tplResult0, cv::TM_SQDIFF_NORMED);

						int modx = _tplMat.cols % 2, mody = _tplMat.rows % 2;
						cv::Mat tplResultMap;
						cv::copyMakeBorder(tplResult0, tplResultMap, (_tplMat.rows - mody) / 2, _traceMat.rows - tplResult0.rows - (_tplMat.rows - mody) / 2,
							(_tplMat.cols - modx) / 2, _traceMat.cols - tplResult0.cols - (_tplMat.cols - modx) / 2, cv::BORDER_REPLICATE);

						//减去模板匹配的结果
						mmRescaling -= tplResultMap;
						//非极大值抑制
						cv::Mat mask;
						cv::dilate(mmRescaling, mask, cv::Mat());
						cv::compare(mmRescaling, mask, mask, cv::CMP_GE);

						cv::Mat non_plateau_mask;
						cv::erode(mmRescaling, non_plateau_mask, cv::Mat());
						cv::compare(mmRescaling, non_plateau_mask, non_plateau_mask, cv::CMP_GT);
						cv::bitwise_and(mask, non_plateau_mask, mask);

						//去掉分数过低的
						mask &= cv::Mat(mmRescaling > 0.36);
						//限定区域(mmRescaling范围内)
						cv::Rect _rr = cv::Rect(cvRound(rr.x*coeff), cvRound(rr.y*coeff), cvRound(rr.width*coeff), cvRound(rr.height*coeff));

						//候选元件位置
						std::vector<cv::Point> candidates;
						cv::findNonZero(mask(_rr), candidates);

						//过滤
						std::vector<Track> _vParts;
						for (auto&candidate : candidates) {
							cv::Point pt(candidate.x + _rr.x, candidate.y + _rr.y);
							float confidence = mmRescaling.ptr<float>(pt.y)[pt.x];
							if (confidence > 0.5f) {
								_vParts.push_back(Track(0, 0, confidence, cv::Point2f((float)pt.x, (float)pt.y), std::vector<cv::Point2f>()));
							}
						}

						//目标元件在小图中的位置
						cv::Point2f maxLox;
						//元件位置判断
						if (_vParts.size() <= 0) {
							//大概率终止
							trayEnd = true;
						}
						else if (_vParts.size() == 1) {
							//有可能会出错
							maxLox = cv::Point2f(_vParts[0].Pos.x / coeff, _vParts[0].Pos.y / coeff);
							if (tRecF.contains(maxLox)) {
								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
							}
							else {
								//这里负责处理意外情况（极大可能是元件偏离过多或者料盘中心定位不准确导致的）,
								//采用距离理论位置最近的点(两种方式都失效的概率比较低，如果真的失效那就听天由命吧)
								cv::Mat _mmRescaling, _tplResultMap;
								_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

								//累加的方式
								double maxVal; cv::Point maxLoc;
								cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
								maxLoc += _rr.tl();

								//模板匹配的方式
								double minVal; cv::Point minLoc;
								cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
								minLoc += _rr.tl();

								std::vector<Track> __vParts;
								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

								//排序
								std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

								//在小图中的位置
								maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);

								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
								for (int j = 0; j < 4; j++)
								{
									cv::line(cc, predictBox[j], predictBox[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
								}
#endif
							}
						}
						else {
							//存在多个峰值,先判断分数最高是否位于理论位置
							std::sort(_vParts.begin(), _vParts.end(), std::greater<Track>());
							for (auto&_vPart : _vParts) {
								maxLox = cv::Point2f(_vPart.Pos.x / coeff, _vPart.Pos.y / coeff);
								if (tRecF.contains(maxLox)) {
									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
									break;
								}
							}
							//如果不在则选取距离理论位置最近的
							if (vParts.empty()) {
								//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）
								//,采用距离理论位置最近的点(两种方式都失效的概率比较低)
								cv::Mat _mmRescaling, _tplResultMap;
								_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

								//累加的方式
								double maxVal; cv::Point maxLoc;
								cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
								maxLoc += _rr.tl();

								//模板匹配的方式
								double minVal; cv::Point minLoc;
								cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
								minLoc += _rr.tl();

								std::vector<Track> __vParts;
								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

								//排序
								std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

								//在小图中的位置
								maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);

								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
								for (int j = 0; j < 4; j++)
								{
									cv::line(cc, predictBox[j], predictBox[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
								}
#endif
							}
						}

						if (!vParts.empty()) {
							cv::Rect tRec_ = cv::Rect(cv::Point(cvFloor((((float)maxLox.x)*2.0f - (float)trackLength*2.0f) / 2.0f),
								cvFloor((((float)maxLox.y)*2.0f - (float)trackWidth*4.0f) / 2.0f)),
								cv::Size(cvRound(trackLength*2.0) + 2, cvRound(trackWidth*4.0) + 2))
								&cv::Rect(0, 0, traceMat.cols, traceMat.rows);
							//当作一种辅助手段，无需设置太严格
							double dmax;
							cv::minMaxLoc(traceMat(tRec_).clone(), NULL, &dmax);
							if (dmax < 0.7*taMaxGray) {
								trayEnd = true;
							}
						}
						break;
					}
					//追踪终止，选取下一个起点
					if (trayEnd) {
						break;
					}
					//更新位置
					trackCenter = cv::Point2f(vParts[0].Pos.x, vParts[0].Pos.y);
					//更新扫描半径
					trackRadius = cv::norm(trackCenter - reelCenter);
					//更新扫描角度
					trackAngle = atan2((double)trackCenter.y - (double)reelCenter.y, (double)trackCenter.x - (double)reelCenter.x) * 180.0 / PI;
					//更新偏移量(元件角度大小)
					trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180.0 / PI;
					//更新元件间角度
					partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180.0 / PI;
					//追踪到了重复的元件
					if ((trackCenter.x<0 || trackCenter.x>X - 1 ||
						trackCenter.y<0 || trackCenter.y>Y - 1) || trackMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] == 255) {
						found = false;
					}
					else {
						//计算元件位置
						cv::Point2f pts[4];
						calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);
						//标记计数
						lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;
						//标记为已追踪过
						std::vector<cv::Point> vT = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
						cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
						//用于显示
						cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
#ifdef _DEBUG
						for (int j = 0; j < 4; j++)
						{
							cv::line(cc, pts[j], pts[(j + 1) % 4], cv::Scalar(14, 173, 238, 255), 1);
						}
#endif
					}
					//清空下一个
					vParts.resize(0);
					//跳过执行
					if (killProcessID == 0) {
						logger.t("eyemCountObjectIrregularPartsE 追踪阶段被跳过执行...");
						found = false;
					}
					trackEnd = (!found);
				} while (!trackEnd);
			}

			//逆时针
			{
				//追踪起点
				cv::Point2f trackCenter(startCenter.x, startCenter.y);
				//追踪角度、半径
				double trackAngle = startAngle, trackRadius = startRadius;
				//元件本身角度
				double trackOffset = dOffset;
				//元件间间距
				double partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
				//开始追踪
				bool trackEnd = true;
				//
				do
				{
					bool found = true; bool trayEnd = false;
					std::vector<Track> vParts;
					for (double t = trackAngle - (trackOffset + partDist - trackOffset / 12.0); t > trackAngle - (trackOffset + partDist - trackOffset / 12.0) - trackOffset / 6.0; t -= dMinorStep)
					{
						cv::Point2f predicPos;
						predicPos.x = reelCenter.x + (float)trackRadius*(float)cos((trackAngle - (trackOffset + partDist))*c);
						predicPos.y = reelCenter.y + (float)trackRadius*(float)sin((trackAngle - (trackOffset + partDist))*c);
						//如果追踪到图像外追踪终止
						if (cvRound(predicPos.x) < 0 || (cvRound(predicPos.x) > X - 1) || cvRound(predicPos.y) < 0 || (cvRound(predicPos.y) > Y - 1)) {
							trayEnd = true;
							break;
						}
						//感兴趣区域(向外扩展了一个元件,防止中心定位出现偏差或者料盘本身变形导致的偏差)
						cv::Point2f predicBox[4];
						calcRotateRect(predicPos, (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, predicBox);

						cv::RotatedRect r(predicBox[0], predicBox[1], predicBox[2]);
						cv::Rect rLimits = r.boundingRect()&cv::Rect(0, 0, X, Y);

						//获取感兴趣区域
						float matx[6];
						cv::Mat traceMat = getTrackMat(srcPrevS(rLimits).clone()
							, (trackAngle - (trackOffset + partDist)) + 90.0, fillVal, matx);

						//计算原图中的点在旋转后的位置(即在traceMat中的精确位置)
						cv::Point2f predictBoxR[4];
						for (int j = 0; j < 4; j++)
						{
							predictBoxR[j].x = matx[0] * (predicBox[j].x - (float)rLimits.x) + matx[1] * (predicBox[j].y - (float)rLimits.y) + matx[2];
							predictBoxR[j].y = matx[3] * (predicBox[j].x - (float)rLimits.x) + matx[4] * (predicBox[j].y - (float)rLimits.y) + matx[5];
						}
						//中点
						cv::Point2f predicPosR((predictBoxR[0].x + predictBoxR[1].x + predictBoxR[2].x + predictBoxR[3].x) / 4.0f,
							(predictBoxR[0].y + predictBoxR[1].y + predictBoxR[2].y + predictBoxR[3].y) / 4.0f);

						//理论区域
						cv::Rect tRec = cv::Rect(cv::Point(cvRound((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f),
							cvRound((predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f)),
							cv::Size(cvRound(trackLength*2.0), cvRound(trackWidth*4.0)))
							&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

						//高精度理论区域
						cv::Rect_<float> tRecF = cv::Rect_<float>(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f,
							(predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f),
							cv::Size2f((float)trackLength*2.0f, (float)trackWidth*4.0f))
							&cv::Rect_<float>(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

						//理论区域向外扩展(即predictBox范围)
						cv::Rect rr = cv::Rect(cv::Point(cvRound((double)predicPosR.x - trackLength*2.0),
							cvRound((double)predicPosR.y - trackWidth*4.0)), cv::Size(cvRound(trackLength*2.0*2.0),
								cvRound(trackWidth*4.0*2.0)))&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

						cv::Rect_<float> rrf = cv::Rect2f(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*4.0f) / 2.0f,
							(predicPosR.y*2.0f - (float)trackWidth*8.0f) / 2.0f), cv::Size2f((float)trackLength*4.0f, (float)trackWidth*8.0f))
							&cv::Rect2f(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

						//元件尺寸太小放大N倍处理，这样坐标会精细些,元件的80%尺寸作为kernel，防止元件尺寸变化太大
						cv::Mat kernel = cv::Mat::ones(cv::Size(cv::max(cvRound((float)(trackLength*2.0) * coeff),
							cvRound((float)(trackWidth*4.0) * coeff)), cv::min(cvRound((float)(trackLength*2.0) * coeff),
								cvRound((float)(trackWidth*4.0) * coeff))), CV_32FC1);
						cv::Mat _traceMat = traceMat.clone();
						//放大
						if (coeff > 1.0f) {
							cv::resize(_traceMat, _traceMat, cv::Size(cvRound(traceMat.size().width * coeff), cvRound(traceMat.size().height * coeff)));
						}
						//计算最大值(当_traceMat尺寸小于kernel会报错)
						cv::Mat dst;
						cv::filter2D(_traceMat, dst, CV_32F, kernel);
						//归一化
						cv::Mat mmRescaling;
						cv::normalize(dst, mmRescaling, 1.0, 0.0, cv::NORM_MINMAX);

						//模板匹配,为了尽量避免定位出错
						cv::Mat _tplMat;
						tplMat.convertTo(_tplMat, CV_32FC1);
						if (coeff > 1.0f) {
							cv::resize(_tplMat, _tplMat, cv::Size(), coeff, coeff);
						}
						//防止报错
						if (_tplMat.cols > _traceMat.cols || _tplMat.rows > _traceMat.rows) {
							return FUNC_CANNOT_CALC;
						}
						//考虑并行计算两个模板结果
						cv::Mat tplResult0;
						cv::matchTemplate(_traceMat, _tplMat, tplResult0, cv::TM_SQDIFF_NORMED);

						int modx = _tplMat.cols % 2, mody = _tplMat.rows % 2;
						cv::Mat tplResultMap;
						cv::copyMakeBorder(tplResult0, tplResultMap, (_tplMat.rows - mody) / 2, _traceMat.rows - tplResult0.rows - (_tplMat.rows - mody) / 2,
							(_tplMat.cols - modx) / 2, _traceMat.cols - tplResult0.cols - (_tplMat.cols - modx) / 2, cv::BORDER_REPLICATE);

						//减去模板匹配的结果
						mmRescaling -= tplResultMap;
						//非极大值抑制
						cv::Mat mask;
						cv::dilate(mmRescaling, mask, cv::Mat());
						cv::compare(mmRescaling, mask, mask, cv::CMP_GE);

						cv::Mat non_plateau_mask;
						cv::erode(mmRescaling, non_plateau_mask, cv::Mat());
						cv::compare(mmRescaling, non_plateau_mask, non_plateau_mask, cv::CMP_GT);
						cv::bitwise_and(mask, non_plateau_mask, mask);

						//去掉分数过低的
						mask &= cv::Mat(mmRescaling > 0.36);
						//限定区域(mmRescaling范围内)
						cv::Rect _rr = cv::Rect(cvRound(rr.x*coeff), cvRound(rr.y*coeff), cvRound(rr.width*coeff), cvRound(rr.height*coeff));
						//候选元件位置
						std::vector<cv::Point> candidates;
						cv::findNonZero(mask(_rr), candidates);

						//过滤
						std::vector<Track> _vParts;
						for (auto&candidate : candidates) {
							cv::Point pt(candidate.x + _rr.x, candidate.y + _rr.y);
							float confidence = mmRescaling.ptr<float>(pt.y)[pt.x];
							if (confidence > 0.5f) {
								_vParts.push_back(Track(0, 0, confidence, cv::Point2f((float)pt.x, (float)pt.y), std::vector<cv::Point2f>()));
							}
						}
						//目标元件在小图中的位置
						cv::Point2f maxLox;
						//元件位置判断
						if (_vParts.size() <= 0) {
							//大概率终止
							trayEnd = true;
						}
						else if (_vParts.size() == 1) {
							maxLox = cv::Point2f(_vParts[0].Pos.x / coeff, _vParts[0].Pos.y / coeff);
							//有可能会出错，当靠的太近可能只存在一个峰值
							if (tRecF.contains(maxLox)) {
								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
							}
							else {
								//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）,采用距离理论位置最近的点(两种方式都失效的概率比较低)
								cv::Mat _mmRescaling, _tplResultMap;
								_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

								//累加的方式
								double maxVal; cv::Point maxLoc;
								cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
								maxLoc += _rr.tl();

								//模板匹配的方式
								double minVal; cv::Point minLoc;
								cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
								minLoc += _rr.tl();

								std::vector<Track> __vParts;
								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

								//排序
								std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

								//小图中的定位坐标
								maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);
								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
								for (int j = 0; j < 4; j++)
								{
									cv::line(cc, predicBox[j], predicBox[(j + 1) % 4], cv::Scalar(0, 0, 238, 255), 1);
								}
#endif
							}
						}
						else {
							//存在定位出错的可能性,先判断分数最高是否位于理论位置
							std::sort(_vParts.begin(), _vParts.end(), std::greater<Track>());
							for (auto&_vPart : _vParts) {
								maxLox = cv::Point2f(_vPart.Pos.x / coeff, _vPart.Pos.y / coeff);
								if (tRecF.contains(maxLox)) {
									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
									break;
								}
							}
							//如果不在则选取距离理论位置最近的
							if (vParts.empty()) {
								//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）,采用距离理论位置最近的点(两种方式都失效的概率比较低)
								cv::Mat _mmRescaling, _tplResultMap;
								_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

								//累加的方式
								double maxVal; cv::Point maxLoc;
								cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
								maxLoc += _rr.tl();

								//模板匹配的方式
								double minVal; cv::Point minLoc;
								cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
								minLoc += _rr.tl();

								std::vector<Track> __vParts;
								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

								//排序
								std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

								//小图中的位置
								maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);
								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
								for (int j = 0; j < 4; j++)
								{
									cv::line(cc, predicBox[j], predicBox[(j + 1) % 4], cv::Scalar(0, 0, 238, 255), 1);
								}
#endif
							}
						}
						if (!vParts.empty()) {
							cv::Rect tRec_ = cv::Rect(cv::Point(cvFloor((((float)maxLox.x)*2.0f - (float)trackLength*2.0f) / 2.0f),
								cvFloor((((float)maxLox.y)*2.0f - (float)trackWidth*4.0f) / 2.0f)),
								cv::Size(cvRound(trackLength*2.0) + 2, cvRound(trackWidth*4.0) + 2))
								&cv::Rect(0, 0, traceMat.cols, traceMat.rows);
							//当作一种辅助手段，无需设置太严格
							double dmax;
							cv::minMaxLoc(traceMat(tRec_).clone(), NULL, &dmax);
							if (dmax < 0.7*taMaxGray) {
								trayEnd = true;
							}
						}
						break;
					}
					//接着下一个起点
					if (trayEnd) {
						break;
					}
					//更新位置
					trackCenter = cv::Point2f(vParts[0].Pos.x, vParts[0].Pos.y);
					//更新扫描半径
					trackRadius = cv::norm(trackCenter - reelCenter);
					//更新扫描角度
					trackAngle = atan2((double)trackCenter.y - (double)reelCenter.y, (double)trackCenter.x - (double)reelCenter.x) * 180.0 / PI;
					//更新偏移量(元件角度大小)
					trackOffset = (2.0 * asin(2.0 * trackLength / (2.0 * trackRadius))) * 180.0 / PI;
					//更新元件间角度
					partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
					//追踪到了重复的元件
					if ((trackCenter.x<0 || trackCenter.x>X - 1 ||
						trackCenter.y<0 || trackCenter.y>Y - 1) || trackMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] == 255) {
						found = false;
					}
					else {
						//计算元件位置
						cv::Point2f pts[4];
						calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);
						//标记计数
						lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;
						//标记为已追踪过
						std::vector<cv::Point> vT = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
						cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
						//用于显示
						cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
#ifdef _DEBUG
						for (int j = 0; j < 4; j++)
						{
							cv::line(cc, pts[j], pts[(j + 1) % 4], cv::Scalar(102, 205, 0, 255), 1);
						}
#endif
					}
					//继续下一个起点
					vParts.resize(0);
					//跳过执行
					if (killProcessID == 0) {
						logger.t("eyemCountObjectIrregularParts 追踪阶段被跳过执行...");
						found = false;
					}
					trackEnd = (!found);
				} while (!trackEnd);
			}
		}
		//计数
		binary = lbMat.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.ptr<uint8_t>(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 FUNC_CANNOT_CALC;
		//统计元件面积
		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;

		//2021/08/26增加测试用
		cv::morphologyEx(image, image, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(45, 45)));
		//获取最大轮廓
		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);
		//追踪锚点
		struct TracingAnchor
		{
			float Size;
			float Length, Height;
			cv::Point2f Anchor;
			cv::RotatedRect RBox;
			TracingAnchor(cv::Point2f Anchor, float Length, float Height, float Size, cv::RotatedRect RBox) :Anchor(Anchor), Length(Length), Height(Height), Size(Size), RBox(RBox) {}
			bool operator >(const TracingAnchor &te)const
			{
				return Size > te.Size;
			}
			bool operator <(const TracingAnchor &te)const
			{
				return Size < te.Size;
			}
		};
		std::vector<std::vector<cv::Point>> contourTracing;
		cv::findContours(image, contourTracing, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
		//所有追踪锚点
		std::vector<TracingAnchor> tracingAnchors;
		for (auto&contour : contourTracing) {
			cv::RotatedRect rbox = cv::minAreaRect(contour);
			if (cv::min(rbox.size.width, rbox.size.height) > 2.0f) {
				tracingAnchors.push_back(TracingAnchor(rbox.center, cv::max(rbox.size.width, rbox.size.height), cv::min(rbox.size.width, rbox.size.height), rbox.size.area(), rbox));
			}
		}
		//不存在独立元件
		if (tracingAnchors.empty()) {
			return FUNC_CANNOT_CALC;
		}
		//尺寸只计算一次
		std::sort(tracingAnchors.begin(), tracingAnchors.end(), std::greater<TracingAnchor>());
		//
		struct Track {
			int iLimit, iPartSize;
			double dMatchDeg = 0.0;
			cv::Point2f Pos;
			std::vector<cv::Point2f> Rect;
			Track() {};
			Track(int iLimit, int iPartSize, double dMatchDeg, cv::Point2f 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;
			}
			bool operator <(const Track &te)const
			{
				return dMatchDeg < te.dMatchDeg;
			}
		};

		//缩放比例
		float coeff = 1.0f;
		//填充值
		const int fillVal = 255 - backThresh;
		//元件尺寸
		const double taLength = tracingAnchors[tracingAnchors.size() / 2].Length; const double taHeight = tracingAnchors[tracingAnchors.size() / 2].Height;
		//元件灰度值
		double taMaxGray = 0.0;
		//标签图
		unsigned char *ucpTrackLabel = new unsigned char[Y*X]();
		cv::Mat trackMat(Y, X, CV_8UC1, ucpTrackLabel);
		//计数图像
		cv::Mat lbMat(Y, X, CV_8UC1, cv::Scalar(0));
		//定位图像
		cv::Mat srcPrevS, tplMat;//模板文件
		srcPrev.convertTo(srcPrevS, CV_32F);
		//随机打乱顺序（降低计算错误dChordL的可能性，也为了测试在起点信息不同时的稳定性）
		std::random_shuffle(tracingAnchors.begin(), tracingAnchors.end());
		//开始确定起点（现在是用圆轨迹来追踪，不排除用螺旋线轨迹来追踪）
		for (std::vector<TracingAnchor>::iterator itvx = tracingAnchors.begin(); itvx != tracingAnchors.end(); ++itvx) {
			//跳过执行
			if (killProcessID == 0) {
				logger.t("eyemCountObjectIrregularParts 点料阶段被跳过执行...");
				break;
			}
			//起始位置信息
			TracingAnchor ta = (*itvx);
			//起始位置坐标
			cv::Point2f startCenter(ta.Anchor.x, ta.Anchor.y);
			//最小外包矩形
			cv::Point2f _pts[4];
			ta.RBox.points(_pts);
			//已做标记(TODO:考虑增加判断哪些是起点哪些不是)
			if (trackMat.ptr<uint8_t>(cvRound(startCenter.y))[cvRound(startCenter.x)] == 255) {
				continue;
			}
			//获取模板图像(是否每次起点都计算模板，如果元件变形过大是否还会有用？)
			if (tplMat.empty())
			{
				float tDist = ta.Height / 2.0f;
				//理论范围扩展
				cv::Rect _rLimits = cv::Rect(cv::Point2i(cvRound((float)ta.RBox.boundingRect2f().tl().x - tDist),
					cvRound((float)ta.RBox.boundingRect2f().tl().y - tDist)), cv::Point2i(cvRound((float)ta.RBox.boundingRect2f().br().x + tDist),
						cvRound((float)ta.RBox.boundingRect2f().br().y + tDist))
				)&cv::Rect(0, 0, X, Y);

				//确定元件位置根据旋转后的位置确定（前提是料盘中心定位的准确）
				double t = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180.0 / PI;
				//计算旋转角度
				cv::Mat traceMat = srcPrev(_rLimits);
				//这里计算得出的模板不是很对,但是对于太小的元件最小外包矩形会不对
				float matx[6];
				tplMat = getTrackMat(traceMat, t + 90.0, 0, matx);
				//变换后的坐标
				cv::Point2f __pts[4];
				for (int j = 0; j < 4; j++)
				{
					__pts[j].x = matx[0] * (_pts[j].x - (float)_rLimits.x) + matx[1] * (_pts[j].y - (float)_rLimits.y) + matx[2];
					__pts[j].y = matx[3] * (_pts[j].x - (float)_rLimits.x) + matx[4] * (_pts[j].y - (float)_rLimits.y) + matx[5];
				}
				//中点
				cv::Point2f __ptsc((__pts[0].x + __pts[1].x + __pts[2].x + __pts[3].x) / 4.0f, (__pts[0].y + __pts[1].y + __pts[2].y + __pts[3].y) / 4.0f);

				//元件区域坐标
				cv::Point2f __mpts[4];
				__mpts[0].x = __ptsc.x - ta.Length / 2.0f; __mpts[0].y = __ptsc.y - ta.Height / 2.0f;
				__mpts[1].x = __ptsc.x + ta.Length / 2.0f; __mpts[1].y = __ptsc.y - ta.Height / 2.0f;
				__mpts[2].x = __ptsc.x - ta.Length / 2.0f; __mpts[2].y = __ptsc.y + ta.Height / 2.0f;
				__mpts[3].x = __ptsc.x + ta.Length / 2.0f; __mpts[3].y = __ptsc.y + ta.Height / 2.0f;
				//元件区域
				cv::Rect _rr(cvFloor(std::min(std::min(std::min(__mpts[0].x, __mpts[1].x), __mpts[2].x), __mpts[3].x)),
					cvFloor(std::min(std::min(std::min(__mpts[0].y, __mpts[1].y), __mpts[2].y), __mpts[3].y)),
					cvCeil(std::max(std::max(std::max(__mpts[0].x, __mpts[1].x), __mpts[2].x), __mpts[3].x)),
					cvCeil(std::max(std::max(std::max(__mpts[0].y, __mpts[1].y), __mpts[2].y), __mpts[3].y))); _rr.width -= _rr.x - 1; _rr.height -= _rr.y - 1;

				//最终模板(可能由于太小，angle是错误的)
				tplMat = tplMat(_rr).clone();
				//缩放比例
				if (MIN(tplMat.size().width, tplMat.size().height) < 12.0) {
					coeff = 2.0f;
				}
				//最大值
				cv::minMaxLoc(tplMat, NULL, &taMaxGray);
			}
			//标记为已追踪过
			std::vector<cv::Point> vT = { cv::Point(_pts[0]),cv::Point(_pts[1]) ,cv::Point(_pts[2]) ,cv::Point(_pts[3]) };
			cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
			//标记计数
			lbMat.ptr<uint8_t>(cvRound(startCenter.y))[cvRound(startCenter.x)] = 255;
			//标记当前位置
			cv::drawMarker(cc, cv::Point(startCenter), cv::Scalar(0, 255, 0, 255), cv::MARKER_DIAMOND, 5);
			//扫描步长
			const double dMinorStep = 0.1;
			//追踪长宽
			const double trackLength = taLength / 2.0, trackWidth = taHeight / 4.0;//是否用较小尺寸的窗口
			//起始扫描角度
			const double startAngle = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180.0 / PI;
			//起始扫描半径
			const double startRadius = cv::norm(startCenter - reelCenter);
			//偏移角度（元件尺寸）
			const double dOffset = (2.0 * asin(2.0 * trackLength / (2.0 * startRadius))) * 180.0 / PI;
			//扫描角度（默认15度范围内存在元件）
			const double dScanRange = 15.0;
			//追踪元件间距(弦长，可以尽量避免因个别器件偏离导致的追踪中断)
			double dChordL = .0;
			for (double t = startAngle + dOffset / 1.5; t < startAngle + dScanRange; t += dMinorStep)
			{
				float x = float(reelCenter.x + startRadius*cos(t*c));
				float y = float(reelCenter.y + startRadius*sin(t*c));
				//防止超出图像范围
				if (cvRound(x) < 0 || (cvRound(x) > X - 1) || cvRound(y) < 0 || (cvRound(y) > Y - 1)) {
					break;
				}
				//确定是否是下一个元件
				if (trackMat.ptr<uint8_t>(cvRound(y))[cvRound(x)] == 255) {
					continue;
				}
				//初次确定元件间距
				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)));
#ifdef _DEBUG
				cv::line(cc, p1, p2, cv::Scalar(0, 215, 255, 255), 1);
#endif
				cv::LineIterator it(binary, p1, p2, 4);
				for (int n = 0; n < it.count; n++, ++it)
				{
					if (binary.ptr<uint8_t>(it.pos().y)[it.pos().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 > 2.0)
					break;
			}
			//没确定出元件间距一般为结尾处，继续从下一个起点计算弦长并开始追踪
			if (dChordL <= 2.0) {
				continue;
			}
			//顺时针(是否并行取决于在windows下运行还是树莓派上)
			{
				//追踪中心
				cv::Point2f trackCenter = cv::Point2f(startCenter.x, startCenter.y);
				//追踪角度、半径
				double trackAngle = startAngle, trackRadius = startRadius;
				//元件本身所占角度
				double trackOffset = dOffset;
				//元件间间距
				double partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
				//开始追踪
				bool trackEnd = true;
				do
				{
					bool found = true; bool trayEnd = false;
					std::vector<Track> vParts;
					for (double t = trackAngle + (trackOffset + partDist - trackOffset / 12.0); t < trackAngle + (trackOffset + partDist - trackOffset / 12.0) + trackOffset / 6.0; t += dMinorStep)
					{
						cv::Point2f predicPos;
						predicPos.x = reelCenter.x + (float)trackRadius*(float)cos((trackAngle + (trackOffset + partDist))*c);
						predicPos.y = reelCenter.y + (float)trackRadius*(float)sin((trackAngle + (trackOffset + partDist))*c);
						//如果追踪到图像外则追踪终止
						if (cvRound(predicPos.x) < 0 || (cvRound(predicPos.x) > X - 1) || cvRound(predicPos.y) < 0 || (cvRound(predicPos.y) > Y - 1)) {
							trayEnd = true;
							break;
						}
						//感兴趣区域(向外扩展了一个元件,防止中心定位出现偏差或者料盘本身变形导致的偏差)
						cv::Point2f predictBox[4];
						calcRotateRect(predicPos, (float)(trackAngle + (trackOffset + partDist)), (float)trackLength + (float)trackLength, (float)trackWidth + (float)trackWidth, predictBox);

						cv::RotatedRect r(predictBox[0], predictBox[1], predictBox[2]);
						cv::Rect rLimits = r.boundingRect()&cv::Rect(0, 0, X, Y);

						//获取感兴趣区域
						float matx[6];
						cv::Mat traceMat = getTrackMat(srcPrevS(rLimits).clone()
							, (trackAngle + (trackOffset + partDist)) + 90.0, fillVal, matx);

						//计算原图中的点在旋转后的位置(即在traceMat中的精确位置)
						cv::Point2f predictBoxR[4];
						for (int j = 0; j < 4; j++)
						{
							predictBoxR[j].x = matx[0] * (predictBox[j].x - (float)rLimits.x) + matx[1] * (predictBox[j].y - (float)rLimits.y) + matx[2];
							predictBoxR[j].y = matx[3] * (predictBox[j].x - (float)rLimits.x) + matx[4] * (predictBox[j].y - (float)rLimits.y) + matx[5];
						}
						//中点
						cv::Point2f predicPosR((predictBoxR[0].x + predictBoxR[1].x + predictBoxR[2].x + predictBoxR[3].x) / 4.0f,
							(predictBoxR[0].y + predictBoxR[1].y + predictBoxR[2].y + predictBoxR[3].y) / 4.0f);

						//理论区域
						cv::Rect tRec = cv::Rect(cv::Point(cvRound((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f),
							cvRound((predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f)),
							cv::Size(cvRound(trackLength*2.0), cvRound(trackWidth*4.0)))
							&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

						//高精度理论区域
						cv::Rect_<float> tRecF = cv::Rect_<float>(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f,
							(predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f),
							cv::Size2f((float)trackLength*2.0f, (float)trackWidth*4.0f))
							&cv::Rect_<float>(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

						//理论区域向外扩展(即predictBox范围)
						cv::Rect rr = cv::Rect(cv::Point(cvRound((double)predicPosR.x - trackLength*2.0),
							cvRound((double)predicPosR.y - trackWidth*4.0)), cv::Size(cvRound(trackLength*2.0*2.0),
								cvRound(trackWidth*4.0*2.0)))&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

						cv::Rect_<float> rrf = cv::Rect2f(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*4.0f) / 2.0f,
							(predicPosR.y*2.0f - (float)trackWidth*8.0f) / 2.0f), cv::Size2f((float)trackLength*4.0f, (float)trackWidth*8.0f))
							&cv::Rect2f(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

						//元件尺寸太小放大N倍处理，这样坐标会精细些,考虑元件的80%尺寸作为kernel，防止元件尺寸变化太大
						cv::Mat kernel = cv::Mat::ones(cv::Size(cv::max(cvRound((float)(trackLength*2.0) * coeff),
							cvRound((float)(trackWidth*4.0) * coeff)), cv::min(cvRound((float)(trackLength*2.0) * coeff),
								cvRound((float)(trackWidth*4.0) * coeff))), CV_32FC1);

						cv::Mat _traceMat = traceMat.clone();
						//放大
						if (coeff > 1.0f) {
							cv::resize(_traceMat, _traceMat, cv::Size(cvRound(traceMat.size().width * coeff), cvRound(traceMat.size().height * coeff)));
						}

						//计算最大值(当_traceMat尺寸小于kernel会报错)
						cv::Mat dst;
						cv::filter2D(_traceMat, dst, CV_32F, kernel);

						//归一化
						cv::Mat mmRescaling;
						cv::normalize(dst, mmRescaling, 1.0, 0.0, cv::NORM_MINMAX);

						//模板匹配做辅助判断,为了尽量避免定位出错
						cv::Mat _tplMat;
						tplMat.convertTo(_tplMat, CV_32FC1);
						if (coeff > 1.0f) {
							cv::resize(_tplMat, _tplMat, cv::Size(), coeff, coeff);
						}
						//防止报错
						if (_tplMat.cols > _traceMat.cols || _tplMat.rows > _traceMat.rows) {
							return FUNC_CANNOT_CALC;
						}
						//考虑并行计算两个模板结果
						cv::Mat tplResult0;
						cv::matchTemplate(_traceMat, _tplMat, tplResult0, cv::TM_SQDIFF_NORMED);

						int modx = _tplMat.cols % 2, mody = _tplMat.rows % 2;
						cv::Mat tplResultMap;
						cv::copyMakeBorder(tplResult0, tplResultMap, (_tplMat.rows - mody) / 2, _traceMat.rows - tplResult0.rows - (_tplMat.rows - mody) / 2,
							(_tplMat.cols - modx) / 2, _traceMat.cols - tplResult0.cols - (_tplMat.cols - modx) / 2, cv::BORDER_REPLICATE);

						//减去模板匹配的结果
						mmRescaling -= tplResultMap;
						//非极大值抑制
						cv::Mat mask;
						cv::dilate(mmRescaling, mask, cv::Mat());
						cv::compare(mmRescaling, mask, mask, cv::CMP_GE);

						cv::Mat non_plateau_mask;
						cv::erode(mmRescaling, non_plateau_mask, cv::Mat());
						cv::compare(mmRescaling, non_plateau_mask, non_plateau_mask, cv::CMP_GT);
						cv::bitwise_and(mask, non_plateau_mask, mask);

						//去掉分数过低的
						mask &= cv::Mat(mmRescaling > 0.36);
						//限定区域(mmRescaling范围内)
						cv::Rect _rr = cv::Rect(cvRound(rr.x*coeff), cvRound(rr.y*coeff), cvRound(rr.width*coeff), cvRound(rr.height*coeff));

						//候选元件位置
						std::vector<cv::Point> candidates;
						cv::findNonZero(mask(_rr), candidates);

						//过滤
						std::vector<Track> _vParts;
						for (auto&candidate : candidates) {
							cv::Point pt(candidate.x + _rr.x, candidate.y + _rr.y);
							float confidence = mmRescaling.ptr<float>(pt.y)[pt.x];
							if (confidence > 0.5f) {
								_vParts.push_back(Track(0, 0, confidence, cv::Point2f((float)pt.x, (float)pt.y), std::vector<cv::Point2f>()));
							}
						}

						//目标元件在小图中的位置
						cv::Point2f maxLox;
						//元件位置判断
						if (_vParts.size() <= 0) {
							//大概率终止
							trayEnd = true;
						}
						else if (_vParts.size() == 1) {
							//有可能会出错
							maxLox = cv::Point2f(_vParts[0].Pos.x / coeff, _vParts[0].Pos.y / coeff);
							if (tRecF.contains(maxLox)) {
								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
							}
							else {
								//这里负责处理意外情况（极大可能是元件偏离过多或者料盘中心定位不准确导致的）,
								//采用距离理论位置最近的点(两种方式都失效的概率比较低，如果真的失效那就听天由命吧)
								cv::Mat _mmRescaling, _tplResultMap;
								_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

								//累加的方式
								double maxVal; cv::Point maxLoc;
								cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
								maxLoc += _rr.tl();

								//模板匹配的方式
								double minVal; cv::Point minLoc;
								cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
								minLoc += _rr.tl();

								std::vector<Track> __vParts;
								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

								//排序
								std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

								//在小图中的位置
								maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);

								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
								for (int j = 0; j < 4; j++)
								{
									cv::line(cc, predictBox[j], predictBox[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
								}
#endif
							}
						}
						else {
							//存在多个峰值,先判断分数最高是否位于理论位置
							std::sort(_vParts.begin(), _vParts.end(), std::greater<Track>());
							for (auto&_vPart : _vParts) {
								maxLox = cv::Point2f(_vPart.Pos.x / coeff, _vPart.Pos.y / coeff);
								if (tRecF.contains(maxLox)) {
									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
									break;
								}
							}
							//如果不在则选取距离理论位置最近的
							if (vParts.empty()) {
								//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）
								//,采用距离理论位置最近的点(两种方式都失效的概率比较低)
								cv::Mat _mmRescaling, _tplResultMap;
								_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

								//累加的方式
								double maxVal; cv::Point maxLoc;
								cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
								maxLoc += _rr.tl();

								//模板匹配的方式
								double minVal; cv::Point minLoc;
								cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
								minLoc += _rr.tl();

								std::vector<Track> __vParts;
								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

								//排序
								std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

								//在小图中的位置
								maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);

								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
								for (int j = 0; j < 4; j++)
								{
									cv::line(cc, predictBox[j], predictBox[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
								}
#endif
							}
						}

						if (!vParts.empty()) {
							cv::Rect tRec_ = cv::Rect(cv::Point(cvFloor((((float)maxLox.x)*2.0f - (float)trackLength*2.0f) / 2.0f),
								cvFloor((((float)maxLox.y)*2.0f - (float)trackWidth*4.0f) / 2.0f)),
								cv::Size(cvRound(trackLength*2.0) + 2, cvRound(trackWidth*4.0) + 2))
								&cv::Rect(0, 0, traceMat.cols, traceMat.rows);
							//当作一种辅助手段，无需设置太严格
							double dmax;
							cv::minMaxLoc(traceMat(tRec_).clone(), NULL, &dmax);
							if (dmax < 0.65*taMaxGray) {
								trayEnd = true;
							}
						}
						break;
					}
					//追踪终止，选取下一个起点
					if (trayEnd) {
						break;
					}
					//更新位置
					trackCenter = cv::Point2f(vParts[0].Pos.x, vParts[0].Pos.y);
					//更新扫描半径
					trackRadius = cv::norm(trackCenter - reelCenter);
					//更新扫描角度
					trackAngle = atan2((double)trackCenter.y - (double)reelCenter.y, (double)trackCenter.x - (double)reelCenter.x) * 180.0 / PI;
					//更新偏移量(元件角度大小)
					trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180.0 / PI;
					//更新元件间角度
					partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180.0 / PI;
					//追踪到了重复的元件
					if ((trackCenter.x<0 || trackCenter.x>X - 1 ||
						trackCenter.y<0 || trackCenter.y>Y - 1) || trackMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] == 255) {
						found = false;
					}
					else {
						//计算元件位置
						cv::Point2f pts[4];
						calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);
						//标记计数
						lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;
						//标记为已追踪过
						std::vector<cv::Point> vT = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
						cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
						//用于显示
						cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
#ifdef _DEBUG
						for (int j = 0; j < 4; j++)
						{
							cv::line(cc, pts[j], pts[(j + 1) % 4], cv::Scalar(14, 173, 238, 255), 1);
						}
#endif
					}
					//清空下一个
					vParts.resize(0);
					//跳过执行
					if (killProcessID == 0) {
						logger.t("eyemCountObjectIrregularPartsE 追踪阶段被跳过执行...");
						found = false;
					}
					trackEnd = (!found);
				} while (!trackEnd);
			}

			//逆时针
			{
				//追踪起点
				cv::Point2f trackCenter(startCenter.x, startCenter.y);
				//追踪角度、半径
				double trackAngle = startAngle, trackRadius = startRadius;
				//元件本身角度
				double trackOffset = dOffset;
				//元件间间距
				double partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
				//开始追踪
				bool trackEnd = true;
				//
				do
				{
					bool found = true; bool trayEnd = false;
					std::vector<Track> vParts;
					for (double t = trackAngle - (trackOffset + partDist - trackOffset / 12.0); t > trackAngle - (trackOffset + partDist - trackOffset / 12.0) - trackOffset / 6.0; t -= dMinorStep)
					{
						cv::Point2f predicPos;
						predicPos.x = reelCenter.x + (float)trackRadius*(float)cos((trackAngle - (trackOffset + partDist))*c);
						predicPos.y = reelCenter.y + (float)trackRadius*(float)sin((trackAngle - (trackOffset + partDist))*c);
						//如果追踪到图像外追踪终止
						if (cvRound(predicPos.x) < 0 || (cvRound(predicPos.x) > X - 1) || cvRound(predicPos.y) < 0 || (cvRound(predicPos.y) > Y - 1)) {
							trayEnd = true;
							break;
						}
						//感兴趣区域(向外扩展了一个元件,防止中心定位出现偏差或者料盘本身变形导致的偏差)
						cv::Point2f predicBox[4];
						calcRotateRect(predicPos, (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, predicBox);

						cv::RotatedRect r(predicBox[0], predicBox[1], predicBox[2]);
						cv::Rect rLimits = r.boundingRect()&cv::Rect(0, 0, X, Y);

						//获取感兴趣区域
						float matx[6];
						cv::Mat traceMat = getTrackMat(srcPrevS(rLimits).clone()
							, (trackAngle - (trackOffset + partDist)) + 90.0, fillVal, matx);

						//计算原图中的点在旋转后的位置(即在traceMat中的精确位置)
						cv::Point2f predictBoxR[4];
						for (int j = 0; j < 4; j++)
						{
							predictBoxR[j].x = matx[0] * (predicBox[j].x - (float)rLimits.x) + matx[1] * (predicBox[j].y - (float)rLimits.y) + matx[2];
							predictBoxR[j].y = matx[3] * (predicBox[j].x - (float)rLimits.x) + matx[4] * (predicBox[j].y - (float)rLimits.y) + matx[5];
						}
						//中点
						cv::Point2f predicPosR((predictBoxR[0].x + predictBoxR[1].x + predictBoxR[2].x + predictBoxR[3].x) / 4.0f,
							(predictBoxR[0].y + predictBoxR[1].y + predictBoxR[2].y + predictBoxR[3].y) / 4.0f);

						//理论区域
						cv::Rect tRec = cv::Rect(cv::Point(cvRound((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f),
							cvRound((predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f)),
							cv::Size(cvRound(trackLength*2.0), cvRound(trackWidth*4.0)))
							&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

						//高精度理论区域
						cv::Rect_<float> tRecF = cv::Rect_<float>(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f,
							(predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f),
							cv::Size2f((float)trackLength*2.0f, (float)trackWidth*4.0f))
							&cv::Rect_<float>(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

						//理论区域向外扩展(即predictBox范围)
						cv::Rect rr = cv::Rect(cv::Point(cvRound((double)predicPosR.x - trackLength*2.0),
							cvRound((double)predicPosR.y - trackWidth*4.0)), cv::Size(cvRound(trackLength*2.0*2.0),
								cvRound(trackWidth*4.0*2.0)))&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

						cv::Rect_<float> rrf = cv::Rect2f(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*4.0f) / 2.0f,
							(predicPosR.y*2.0f - (float)trackWidth*8.0f) / 2.0f), cv::Size2f((float)trackLength*4.0f, (float)trackWidth*8.0f))
							&cv::Rect2f(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

						//元件尺寸太小放大N倍处理，这样坐标会精细些,元件的80%尺寸作为kernel，防止元件尺寸变化太大
						cv::Mat kernel = cv::Mat::ones(cv::Size(cv::max(cvRound((float)(trackLength*2.0) * coeff),
							cvRound((float)(trackWidth*4.0) * coeff)), cv::min(cvRound((float)(trackLength*2.0) * coeff),
								cvRound((float)(trackWidth*4.0) * coeff))), CV_32FC1);
						cv::Mat _traceMat = traceMat.clone();
						//放大
						if (coeff > 1.0f) {
							cv::resize(_traceMat, _traceMat, cv::Size(cvRound(traceMat.size().width * coeff), cvRound(traceMat.size().height * coeff)));
						}
						//计算最大值(当_traceMat尺寸小于kernel会报错)
						cv::Mat dst;
						cv::filter2D(_traceMat, dst, CV_32F, kernel);
						//归一化
						cv::Mat mmRescaling;
						cv::normalize(dst, mmRescaling, 1.0, 0.0, cv::NORM_MINMAX);

						//模板匹配,为了尽量避免定位出错
						cv::Mat _tplMat;
						tplMat.convertTo(_tplMat, CV_32FC1);
						if (coeff > 1.0f) {
							cv::resize(_tplMat, _tplMat, cv::Size(), coeff, coeff);
						}
						//防止报错
						if (_tplMat.cols > _traceMat.cols || _tplMat.rows > _traceMat.rows) {
							return FUNC_CANNOT_CALC;
						}
						//考虑并行计算两个模板结果
						cv::Mat tplResult0;
						cv::matchTemplate(_traceMat, _tplMat, tplResult0, cv::TM_SQDIFF_NORMED);

						int modx = _tplMat.cols % 2, mody = _tplMat.rows % 2;
						cv::Mat tplResultMap;
						cv::copyMakeBorder(tplResult0, tplResultMap, (_tplMat.rows - mody) / 2, _traceMat.rows - tplResult0.rows - (_tplMat.rows - mody) / 2,
							(_tplMat.cols - modx) / 2, _traceMat.cols - tplResult0.cols - (_tplMat.cols - modx) / 2, cv::BORDER_REPLICATE);

						//减去模板匹配的结果
						mmRescaling -= tplResultMap;
						//非极大值抑制
						cv::Mat mask;
						cv::dilate(mmRescaling, mask, cv::Mat());
						cv::compare(mmRescaling, mask, mask, cv::CMP_GE);

						cv::Mat non_plateau_mask;
						cv::erode(mmRescaling, non_plateau_mask, cv::Mat());
						cv::compare(mmRescaling, non_plateau_mask, non_plateau_mask, cv::CMP_GT);
						cv::bitwise_and(mask, non_plateau_mask, mask);

						//去掉分数过低的
						mask &= cv::Mat(mmRescaling > 0.36);
						//限定区域(mmRescaling范围内)
						cv::Rect _rr = cv::Rect(cvRound(rr.x*coeff), cvRound(rr.y*coeff), cvRound(rr.width*coeff), cvRound(rr.height*coeff));
						//候选元件位置
						std::vector<cv::Point> candidates;
						cv::findNonZero(mask(_rr), candidates);

						//过滤
						std::vector<Track> _vParts;
						for (auto&candidate : candidates) {
							cv::Point pt(candidate.x + _rr.x, candidate.y + _rr.y);
							float confidence = mmRescaling.ptr<float>(pt.y)[pt.x];
							if (confidence > 0.5f) {
								_vParts.push_back(Track(0, 0, confidence, cv::Point2f((float)pt.x, (float)pt.y), std::vector<cv::Point2f>()));
							}
						}
						//目标元件在小图中的位置
						cv::Point2f maxLox;
						//元件位置判断
						if (_vParts.size() <= 0) {
							//大概率终止
							trayEnd = true;
						}
						else if (_vParts.size() == 1) {
							maxLox = cv::Point2f(_vParts[0].Pos.x / coeff, _vParts[0].Pos.y / coeff);
							//有可能会出错，当靠的太近可能只存在一个峰值
							if (tRecF.contains(maxLox)) {
								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
							}
							else {
								//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）,采用距离理论位置最近的点(两种方式都失效的概率比较低)
								cv::Mat _mmRescaling, _tplResultMap;
								_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

								//累加的方式
								double maxVal; cv::Point maxLoc;
								cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
								maxLoc += _rr.tl();

								//模板匹配的方式
								double minVal; cv::Point minLoc;
								cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
								minLoc += _rr.tl();

								std::vector<Track> __vParts;
								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

								//排序
								std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

								//小图中的定位坐标
								maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);
								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
								for (int j = 0; j < 4; j++)
								{
									cv::line(cc, predicBox[j], predicBox[(j + 1) % 4], cv::Scalar(0, 0, 238, 255), 1);
								}
#endif
							}
						}
						else {
							//存在定位出错的可能性,先判断分数最高是否位于理论位置
							std::sort(_vParts.begin(), _vParts.end(), std::greater<Track>());
							for (auto&_vPart : _vParts) {
								maxLox = cv::Point2f(_vPart.Pos.x / coeff, _vPart.Pos.y / coeff);
								if (tRecF.contains(maxLox)) {
									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
									break;
								}
							}
							//如果不在则选取距离理论位置最近的
							if (vParts.empty()) {
								//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）,采用距离理论位置最近的点(两种方式都失效的概率比较低)
								cv::Mat _mmRescaling, _tplResultMap;
								_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

								//累加的方式
								double maxVal; cv::Point maxLoc;
								cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
								maxLoc += _rr.tl();

								//模板匹配的方式
								double minVal; cv::Point minLoc;
								cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
								minLoc += _rr.tl();

								std::vector<Track> __vParts;
								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

								__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
									cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

								//排序
								std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

								//小图中的位置
								maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);
								//计算旋转前的坐标（即匹配的最终坐标）
								float realX = 0.0f, realY = 0.0f;
								realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
								realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

								//外包矩形顶点
								cv::Point2f pts[4];
								calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

								//
								std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
								vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
								for (int j = 0; j < 4; j++)
								{
									cv::line(cc, predicBox[j], predicBox[(j + 1) % 4], cv::Scalar(0, 0, 238, 255), 1);
								}
#endif
							}
						}
						if (!vParts.empty()) {
							cv::Rect tRec_ = cv::Rect(cv::Point(cvFloor((((float)maxLox.x)*2.0f - (float)trackLength*2.0f) / 2.0f),
								cvFloor((((float)maxLox.y)*2.0f - (float)trackWidth*4.0f) / 2.0f)),
								cv::Size(cvRound(trackLength*2.0) + 2, cvRound(trackWidth*4.0) + 2))
								&cv::Rect(0, 0, traceMat.cols, traceMat.rows);
							//当作一种辅助手段，无需设置太严格
							double dmax;
							cv::minMaxLoc(traceMat(tRec_).clone(), NULL, &dmax);
							if (dmax < 0.65*taMaxGray) {
								trayEnd = true;
							}
						}
						break;
					}
					//接着下一个起点
					if (trayEnd) {
						break;
					}
					//更新位置
					trackCenter = cv::Point2f(vParts[0].Pos.x, vParts[0].Pos.y);
					//更新扫描半径
					trackRadius = cv::norm(trackCenter - reelCenter);
					//更新扫描角度
					trackAngle = atan2((double)trackCenter.y - (double)reelCenter.y, (double)trackCenter.x - (double)reelCenter.x) * 180.0 / PI;
					//更新偏移量(元件角度大小)
					trackOffset = (2.0 * asin(2.0 * trackLength / (2.0 * trackRadius))) * 180.0 / PI;
					//更新元件间角度
					partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
					//追踪到了重复的元件
					if ((trackCenter.x<0 || trackCenter.x>X - 1 ||
						trackCenter.y<0 || trackCenter.y>Y - 1) || trackMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] == 255) {
						found = false;
					}
					else {
						//计算元件位置
						cv::Point2f pts[4];
						calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);
						//标记计数
						lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;
						//标记为已追踪过
						std::vector<cv::Point> vT = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
						cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
						//用于显示
						cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
#ifdef _DEBUG
						for (int j = 0; j < 4; j++)
						{
							cv::line(cc, pts[j], pts[(j + 1) % 4], cv::Scalar(102, 205, 0, 255), 1);
						}
#endif
					}
					//继续下一个起点
					vParts.resize(0);
					//跳过执行
					if (killProcessID == 0) {
						logger.t("eyemCountObjectIrregularParts 追踪阶段被跳过执行...");
						found = false;
					}
					trackEnd = (!found);
				} while (!trackEnd);
			}
		}
		//拷贝计数
		binary = lbMat.clone();
		//释放资源
		delete[] ucpTrackLabel;
		ucpTrackLabel = NULL;
	}
	else if (strcmp(ccSubType, "IP_SQUARE_PARTS") == 0)
	{
		//测试用，对于个别元件需要稍微膨胀一下
		cv::morphologyEx(srcPrev, srcPrev, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2)));
		//二值化
		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.ptr<uint8_t>(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] <= 21) || m2.ptr<int>(i)[cv::CC_STAT_WIDTH] * m2.ptr<int>(i)[cv::CC_STAT_HEIGHT] > 400000)//经验值
			{
				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 FUNC_CANNOT_CALC;
		//统计元件面积
		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.);
		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.35*sinPartSize) || (((int *)m2.data)[(cv::CC_STAT_AREA) + (i)*m2.cols] < 0.45*sinPartSize))//经验值
			{
				colors[i] = 0;
			}
		}
		std::vector<int> trayCount(nccomps + 1, 0);
		Palete pal;
		unsigned int colorCount = 0;
		for (int i = 1; i < nccomps; i++)
		{
			colorCount = cvRound((float)m2.ptr<int>(i)[cv::CC_STAT_AREA] / (float)sinPartSize);
			CvLabel _label = i;
			double r, g, b;
			if (!colors[_label] == 0) {
				_HSV2RGB_((double)((colorCount * 77) % 360), 1., 1., r, g, b);
			}
			else {
				_HSV2RGB_((double)(((colorCount + 2) * 77) % 360), 1., .5, r, g, b);
			}
			pal[_label] = CV_RGB(r, g, b);
			trayCount[_label] = colorCount;
		}

		//认为是粘连
		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);
					if (binary.ptr<uint8_t>(y)[x]) {
						cc.ptr<cv::Vec4b>(y)[x] = cv::Vec4b((uchar)pal[label].val[0], (uchar)pal[label].val[1], (uchar)pal[label].val[2], 255);
					}
					binary.ptr<uint8_t>(y)[x] = colors[label];
				}
			}
		});

		for (int i = 1; i < nccomps; i++)
		{
			CvLabel _label = i;
			if (trayCount[_label] != 1) {
				cv::putText(cc, std::to_string(trayCount[_label]), cv::Point(cvRound(m3.ptr<double>(i)[0]), cvRound(m3.ptr<double>(i)[1])),
					cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(0, 0, 255, 255), 1);
			}
		}
		//计数
		int totalCount = std::accumulate(trayCount.begin(), trayCount.end(), 0);

		//画图显示
		std::string text = "Reel Number = " + std::to_string(totalCount);
		cv::putText(cc, text, cv::Point(35, 35), 0, 1.0, cv::Scalar(0, 140, 255, 255), 2);

		//标记
		binary = cv::Scalar(0);
		for (int t = 0; t < totalCount; t++) {
			binary.ptr<uint8_t>(0)[t] = 255;
		}
	}
	else if (strcmp(ccSubType, "IP_DYNAMIC_PARTS") == 0)
	{
		double threshold = getThreshVal_Otsu_8u(srcPrev);
		//二值化
		cv::threshold(srcPrev, binary, threshold + 25, 255, cv::THRESH_BINARY);
		//去掉一些干扰
		cv::morphologyEx(binary, binary, cv::MORPH_OPEN, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2)));

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

		//计算大概面积
		cv::Mat statsArea = stats(cv::Range(1, stats.rows), cv::Range(4, 5)).clone();
		cv::sort(statsArea, statsArea, cv::SortFlags::SORT_EVERY_COLUMN);

		int meanArea = statsArea.ptr<uint32_t>(cvRound(statsArea.rows / 2))[0];

		//过滤连通域面积<=maxVal的
		std::vector<uchar> colors(nccomps + 1, 0);
		for (int i = 1; i < nccomps; i++) {
			colors[i] = 255;
			if ((stats.ptr<int>(i)[cv::CC_STAT_AREA] < meanArea / 4) || (stats.ptr<int>(i)[cv::CC_STAT_AREA] > 4 * meanArea))
			{
				colors[i] = 0;
			}
		}
		//过滤
		cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
			for (int y = range.start; y < range.end; y++)
			{
				uint8_t *ptrRow = binary.ptr<uint8_t>(y);
				for (int x = 0; x < X; x++)
				{
					int label = labels.ptr<int>(y)[x];
					CV_Assert(0 <= label && label <= nccomps);
					ptrRow[x] = colors[label];
				}
			}
		});

		//计算距离变换
		cv::Mat distMap;
		cv::distanceTransform(binary, distMap, cv::DIST_L2, 3);
		cv::normalize(distMap, distMap, 1, 0, cv::NORM_MINMAX);
		distMap.convertTo(distMap, CV_8UC1, 255);

		//二值化
		cv::threshold(distMap, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);

		//计算大概区域
		cv::Mat mask;
		cv::morphologyEx(binary, mask, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(45, 45)));

		std::vector<std::vector<cv::Point>> contours;
		cv::findContours(mask, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);

		if (contours.empty()) {
			return FUNC_CANNOT_CALC;
		}

		cv::Mat image(Y, X, CV_8UC1, cv::Scalar(0));
		for (int n = 0; n < contours.size(); n++) {
			cv::drawContours(image, contours, n, cv::Scalar(255), -1);
		}

		//寻找最大轮廓
		std::vector<cv::Point> contourMax; double contourMaxArea = 0; cv::Point2f center; float radius;
		contourMax = contours[0]; contourMaxArea = cv::contourArea(contourMax);
		for (int i = 1; i < contours.size(); i++)
		{
			double contourArea = cv::contourArea(contours[i]);
			if (contourArea > contourMaxArea)
			{
				contourMax = contours[i];
				contourMaxArea = contourArea;
			}
		}

		//去除外部干扰
		cv::minEnclosingCircle(contourMax, center, radius);

		cv::Mat maskOut(Y, X, CV_8UC1, cv::Scalar(0));
		cv::circle(maskOut, center, cvRound(radius), cv::Scalar(255), -1);

		binary &= maskOut;

		//
		image -= mask;
		cv::findContours(image, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);

		if (contours.empty()) {
			return FUNC_CANNOT_CALC;
		}

		contourMax = contours[0]; contourMaxArea = cv::contourArea(contourMax);
		for (int i = 1; i < contours.size(); i++)
		{
			double contourArea = cv::contourArea(contours[i]);
			if (contourArea > contourMaxArea)
			{
				contourMax = contours[i];
				contourMaxArea = contourArea;
			}
		}

		//去除内部干扰
		cv::minEnclosingCircle(contourMax, center, radius);
		cv::circle(binary, cv::Point(center), cvRound(radius - 85), cv::Scalar(0), -1);

		cv::Point reelCenter(cvRound(center.x), cvRound(center.y));
		cv::drawMarker(cc, reelCenter, cv::Scalar(0, 0, 238, 255), 1, 35, 2);
		//计数
		nccomps = cv::connectedComponentsWithStats(binary, labels, stats, centroids);
		binary = cv::Scalar(0);
		for (int j = 1; j < nccomps; j++)
		{
			cv::Point pt(cvRound(centroids.ptr<double_t>(j)[0]), cvRound(centroids.ptr<double_t>(j)[1]));
			if (pt.x > 0 && pt.y > 0 && pt.x < X&&pt.y < Y) {
				binary.at<uchar>(pt) = 255;
				cv::circle(cc, pt, 2, cv::Scalar(0, 255, 0, 255), 1);
			}
		}
	}
	else
	{
		//先用自动算法点，如果不行判断为散料
		int trayNum[4];
		int iRet = eyemCountObjectE(tpImage, tpRoi, "", trayNum, tpDstImg);
		if (iRet == FUNC_OK) {
			//输出结果
			for (int i = 0; i < 4; i++) {
				//输出结果
				ipReelNum[i] = trayNum[i];
				break;
			}
			return FUNC_OK;
		}
		else {
			//判断为散料
			cv::threshold(srcPrev, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
			cv::morphologyEx(binary, binary, cv::MORPH_DILATE, 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);

			std::vector<std::vector<cv::Point>> contours, contourFilter;

			//连接在一起(散料用)
			cv::Mat binaryEx;
			cv::morphologyEx(binary, binaryEx, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(75, 75)));

			//掩膜
			cv::Mat mask(Y, X, CV_8UC1, cv::Scalar(0));

			cv::findContours(binaryEx, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
			for (int i = 0; i < contours.size(); i++)
			{
				double contourArea = cv::contourArea(contours[i]);
				if (contourArea > 15000)
				{
					//绘制掩膜
					cv::drawContours(mask, contours, i, cv::Scalar(255), -1);
				}
			}

			//粗略计数
			cv::Mat labels, stats, centroids;
			int numObj = cv::connectedComponentsWithStats(binary&mask, labels, stats, centroids);
			//坐标图
			binary = cv::Scalar(0);
			//画图
			double *dpCent = (double *)centroids.data;
			for (int j = 1; j < numObj; j++)
			{
				//面积过滤
				if (stats.ptr<int>(j)[cv::CC_STAT_AREA] > 2) {
					binary.at<uchar>(cv::Point(cvRound((float)dpCent[(0) + (j) * 2]), cvRound((float)dpCent[(1) + (j) * 2]))) = 255;
				}
			}
		}
	}
	//计数
	std::vector<cv::Point> idx;
	cv::findNonZero(binary, idx);
	//输出数量
	int trayNum = (int)idx.size();
	//画图显示
	std::string text = "Reel Number = " + std::to_string(trayNum);
	cv::putText(cc, text, cv::Point(35, 35), 0, 1.0, cv::Scalar(0, 140, 255, 255), 2);
	//<输出结果
	const int SizeConst = 4;
	//<输出计数结果标记图像
	memset(ipReelNum, 0, SizeConst);

	ipReelNum[0] = trayNum;

	tpDstImg->iWidth = cc.cols; tpDstImg->iHeight = cc.rows; tpDstImg->iDepth = cc.depth(); tpDstImg->iChannels = cc.channels();

	//内存尺寸
	int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);

	//分配/初始化内存
	tpDstImg->vpImage = (uint8_t *)malloc(_Size);
	if (NULL == tpDstImg->vpImage)
		return FUNC_NOT_ENOUGH_MEM;
	memset(tpDstImg->vpImage, 0, _Size);

	//拷贝数据
	memcpy(tpDstImg->vpImage, cc.data, _Size);

	return FUNC_OK;
}

int	eyemCountObjectE(EyemImage tpImage, EyemRect tpRoi, const char *fileName, int *ipReelNum, EyemImage *tpDstImg)
{
	cv::Mat src = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();
	if (src.empty()) {
		return FUNC_IMAGE_NOT_EXIST;
	}
	//转单通道
	if (src.channels() != 1)
		cv::cvtColor(src, src, cv::COLOR_BGR2GRAY);

	//跳过执行
	if (killProcessID == 0) {
		logger.t("eyemCountObjectIrregularPartsE 初始阶段被跳过执行...");
		return FUNC_CANNOT_CALC;
	}
	//图像裁剪
	src = src(cv::Rect(tpRoi.iXs, tpRoi.iYs, tpRoi.iWidth, tpRoi.iHeight)).clone();
	//image size
	int X = src.cols, Y = src.rows;
	//去除局部量斑影响（默认亮斑尺寸不会大于15个像素）
	cv::Mat srcTmp;
	cv::morphologyEx(src, srcTmp, cv::MORPH_ERODE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(15, 15)));

	//去除黑斑影响
	int m = cvRound(cv::mean(src)[0]);
	srcTmp.forEach<uint16_t>([&](uint16_t& pixel, const int *pos)->void {
		pixel = pixel == 0 ? m : pixel;
	});

	//图像增强
	double min, max;
	cv::Point maxId;
	cv::minMaxLoc(srcTmp, &min, &max, NULL, &maxId);
	src.convertTo(src, CV_64FC1);

	src -= min;
	src /= (max - min);
	src *= 65535;
	src.convertTo(src, CV_16UC1);

	cv::Mat src8U;
	src.convertTo(src8U, CV_8UC1, 1 / 255.);
	//显示结果图像
	cv::Mat cc;
	cv::cvtColor(src8U, cc, cv::COLOR_GRAY2BGRA);
	//设置bins
	const int histSize = 17;
	//range of values
	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 * cvRound(((double)maxIdx[0] - 2));//正常-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.ptr<uint8_t>(y)[x] >= backThresh) {
					src8U.ptr<uint8_t>(y)[x] = backThresh;
				}
			}
		}
	});
	//方便显示
	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);
	//连接在一起
	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) {
		for (int i = 0; i < 4; i++) {
			ipReelNum[i] = 0;
		}
		return FUNC_CANNOT_CALC;
	}
	//图像中心
	cv::Point reelCenter(X / 2, Y / 2);
	//料盘排序
	std::vector <TrayPos> sortedTrays;
	for (int i = 0; i < trays.size(); i++)
	{
		//左上角
		if ((int)trays[i].Center.x <= reelCenter.x && (int)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 ((int)trays[i].Center.x <= reelCenter.x && (int)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 ((int)trays[i].Center.x >= reelCenter.x && (int)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 ((int)trays[i].Center.x >= reelCenter.x && (int)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, srcPrevB;
		cv::bitwise_not(sortedTrays[i].Tray, srcPrev);
		//备份
		srcPrevB = srcPrev.clone();
		//二值化可以分别放在两个算法里
		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);
			struct TracingAnchor
			{
				float Size;
				float Length, Height;
				cv::Point2f Anchor;
				cv::RotatedRect RBox;
				TracingAnchor(cv::Point2f Anchor, float Length, float Height, float Size, cv::RotatedRect RBox) :Anchor(Anchor), Length(Length), Height(Height), Size(Size), RBox(RBox) {}
				bool operator >(const TracingAnchor &te)const
				{
					return Size > te.Size;
				}
				bool operator <(const TracingAnchor &te)const
				{
					return Size < te.Size;
				}
			};
			std::vector<std::vector<cv::Point>> contourTracing;
			cv::findContours(image, contourTracing, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
			//所有追踪锚点
			std::vector<TracingAnchor> tracingAnchors;
			for (auto&contour : contourTracing) {
				cv::RotatedRect rbox = cv::minAreaRect(contour);
				if (cv::min(rbox.size.width, rbox.size.height) > 2.0f) {
					tracingAnchors.push_back(TracingAnchor(rbox.center, cv::max(rbox.size.width, rbox.size.height), cv::min(rbox.size.width, rbox.size.height), rbox.size.area(), rbox));
				}
			}
			//不存在独立元件
			if (tracingAnchors.empty()) {
				return FUNC_CANNOT_CALC;
			}
			//尺寸只计算一次
			std::sort(tracingAnchors.begin(), tracingAnchors.end(), std::greater<TracingAnchor>());
			//
			struct Track {
				int iLimit, iPartSize;
				double dMatchDeg = 0.0;
				cv::Point2f Pos;
				std::vector<cv::Point2f> Rect;

				Track() {};

				Track(int iLimit, int iPartSize, double dMatchDeg, cv::Point2f 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;
				}
				bool operator <(const Track &te)const
				{
					return dMatchDeg < te.dMatchDeg;
				}
			};
			//缩放比例
			float coeff = 1.0f;
			//填充值
			const int fillVal = 255 - backThresh;
			//元件尺寸
			const double taLength = tracingAnchors[tracingAnchors.size() / 2].Length; const double taHeight = tracingAnchors[tracingAnchors.size() / 2].Height;
			//元件灰度值
			double taMaxGray = 0.0;
			//标签图
			unsigned char *ucpTrackLabel = new unsigned char[Y*X]();
			cv::Mat trackMat(Y, X, CV_8UC1, ucpTrackLabel);
			//计数图像
			cv::Mat lbMat(Y, X, CV_8UC1, cv::Scalar(0));
			//定位图像
			cv::Mat srcPrevS, tplMat;//模板文件
			srcPrevB.convertTo(srcPrevS, CV_32F);
			//随机打乱顺序（降低计算错误dChordL的可能性，也为了测试在起点信息不同时的稳定性）
			std::random_shuffle(tracingAnchors.begin(), tracingAnchors.end());
			//开始确定起点（现在是用圆轨迹来追踪，不排除用螺旋线轨迹来追踪）
			for (std::vector<TracingAnchor>::iterator itvx = tracingAnchors.begin(); itvx != tracingAnchors.end(); ++itvx) {
				//跳过执行
				if (killProcessID == 0) {
					logger.t("eyemCountObjectIrregularParts 点料阶段被跳过执行...");
					break;
				}
				//起始位置信息
				TracingAnchor ta = (*itvx);
				//起始位置坐标
				cv::Point2f startCenter(ta.Anchor.x, ta.Anchor.y);
				//最小外包矩形
				cv::Point2f _pts[4];
				ta.RBox.points(_pts);
				//已做标记(TODO:考虑增加判断哪些是起点哪些不是)
				if (trackMat.ptr<uint8_t>(cvRound(startCenter.y))[cvRound(startCenter.x)] == 255) {
					continue;
				}
				//获取模板图像(是否每次起点都计算模板，如果元件变形过大是否还会有用？)
				if (tplMat.empty())
				{
					float tDist = ta.Height / 2.0f;
					//理论范围扩展
					cv::Rect _rLimits = cv::Rect(cv::Point2i(cvRound((float)ta.RBox.boundingRect2f().tl().x - tDist),
						cvRound((float)ta.RBox.boundingRect2f().tl().y - tDist)), cv::Point2i(cvRound((float)ta.RBox.boundingRect2f().br().x + tDist),
							cvRound((float)ta.RBox.boundingRect2f().br().y + tDist))
					)&cv::Rect(0, 0, X, Y);

					//确定元件位置根据旋转后的位置确定（前提是料盘中心定位的准确）
					double t = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180.0 / PI;
					//计算旋转角度
					cv::Mat traceMat = srcPrevB(_rLimits);
					//这里计算得出的模板不是很对
					float matx[6];
					tplMat = getTrackMat(traceMat, t + 90.0, 0, matx);
					//变换后的坐标
					cv::Point2f __pts[4];
					for (int j = 0; j < 4; j++)
					{
						__pts[j].x = matx[0] * (_pts[j].x - (float)_rLimits.x) + matx[1] * (_pts[j].y - (float)_rLimits.y) + matx[2];
						__pts[j].y = matx[3] * (_pts[j].x - (float)_rLimits.x) + matx[4] * (_pts[j].y - (float)_rLimits.y) + matx[5];
					}
					cv::Point2f __ptsc((__pts[0].x + __pts[1].x + __pts[2].x + __pts[3].x) / 4.0f, (__pts[0].y + __pts[1].y + __pts[2].y + __pts[3].y) / 4.0f);
					//确定各顶点方位
					struct DIR {
						int i = -1;
						cv::Point2f pt;
						DIR() {};

						DIR(int i, cv::Point2f pt) :i(i), pt(pt) {};
					};
					auto _dir_l = std::vector<DIR>(); auto _dir_r = std::vector<DIR>();
					for (int j = 0; j < 4; j++)
					{
						if (__pts[j].x < __ptsc.x) {
							_dir_l.push_back(DIR(j, __pts[j]));
						}
						else {
							_dir_r.push_back(DIR(j, __pts[j]));
						}
					}
					//重新选点计算模板
					if (_dir_l.size() != _dir_r.size()) {
						continue;
					}
					//确定顶点方向
					cv::Point2f p0, p1, p2, p3;
					if (_dir_l[0].pt.y < _dir_l[1].pt.y) {
						p0 = _pts[_dir_l[0].i];
						p1 = _pts[_dir_l[1].i];
					}
					else {
						p0 = _pts[_dir_l[1].i];
						p1 = _pts[_dir_l[0].i];
					}

					if (_dir_r[0].pt.y > _dir_r[1].pt.y) {
						p2 = _pts[_dir_r[0].i];
						p3 = _pts[_dir_r[1].i];
					}
					else {
						p2 = _pts[_dir_r[1].i];
						p3 = _pts[_dir_r[0].i];
					}
					//计算精确角度
					cv::Point2f p01((p0.x + p1.x) / 2.0f, (p0.y + p1.y) / 2.0f), p23((p2.x + p3.x) / 2.0f, (p2.y + p3.y) / 2.0f);

					double realT = atan2((double)p23.y - (double)p01.y, (double)p23.x - (double)p01.x) * 180.0 / PI;
					cv::Mat realTplMat = getTrackMat(traceMat, realT, 0, matx);

					cv::Point2f __mpts[4];
					for (int j = 0; j < 4; j++)
					{
						__mpts[j].x = matx[0] * (_pts[j].x - (float)_rLimits.x) + matx[1] * (_pts[j].y - (float)_rLimits.y) + matx[2];
						__mpts[j].y = matx[3] * (_pts[j].x - (float)_rLimits.x) + matx[4] * (_pts[j].y - (float)_rLimits.y) + matx[5];
					}

					cv::Rect _rr(cvFloor(std::min(std::min(std::min(__mpts[0].x, __mpts[1].x), __mpts[2].x), __mpts[3].x)),
						cvFloor(std::min(std::min(std::min(__mpts[0].y, __mpts[1].y), __mpts[2].y), __mpts[3].y)),
						cvCeil(std::max(std::max(std::max(__mpts[0].x, __mpts[1].x), __mpts[2].x), __mpts[3].x)),
						cvCeil(std::max(std::max(std::max(__mpts[0].y, __mpts[1].y), __mpts[2].y), __mpts[3].y))); _rr.width -= _rr.x - 1; _rr.height -= _rr.y - 1;

					//最终模板
					tplMat = realTplMat(_rr).clone();
					//缩放比例
					if (MIN(tplMat.size().width, tplMat.size().height) < 12.0) {
						coeff = 2.0f;
					}
					//最大值
					cv::minMaxLoc(tplMat, NULL, &taMaxGray);
				}
				//标记为已追踪过
				std::vector<cv::Point> vT = { cv::Point(_pts[0]),cv::Point(_pts[1]) ,cv::Point(_pts[2]) ,cv::Point(_pts[3]) };
				cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
				//标记计数
				lbMat.ptr<uint8_t>(cvRound(startCenter.y))[cvRound(startCenter.x)] = 255;
				//标记当前位置
				cv::drawMarker(cc, cv::Point(startCenter), cv::Scalar(0, 255, 0, 255), cv::MARKER_DIAMOND, 5);
				//扫描步长
				const double dMinorStep = 0.1;
				//追踪长宽
				const double trackLength = taLength / 2.0, trackWidth = taHeight / 4.0;//是否用较小尺寸的窗口
				//起始扫描角度
				const double startAngle = atan2((double)startCenter.y - reelCenter.y, (double)startCenter.x - reelCenter.x) * 180.0 / PI;
				//起始扫描半径
				const double startRadius = cv::norm(startCenter - reelCenter);
				//偏移角度（元件尺寸）
				const double dOffset = (2.0 * asin(2.0 * trackLength / (2.0 * startRadius))) * 180.0 / PI;
				//扫描角度（默认15度范围内存在元件）
				const double dScanRange = 15.0;
				//追踪元件间距(弦长，可以尽量避免因个别器件偏离导致的追踪中断)
				double dChordL = .0;
				for (double t = startAngle + dOffset / 1.5; t < startAngle + dScanRange; t += dMinorStep)
				{
					float x = float(reelCenter.x + startRadius*cos(t*c));
					float y = float(reelCenter.y + startRadius*sin(t*c));
					//防止超出图像范围
					if (cvRound(x) < 0 || (cvRound(x) > X - 1) || cvRound(y) < 0 || (cvRound(y) > Y - 1)) {
						break;
					}
					//确定是否是下一个元件
					if (trackMat.ptr<uint8_t>(cvRound(y))[cvRound(x)] == 255) {
						continue;
					}
					//初次确定元件间距
					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)));
#ifdef _DEBUG
					cv::line(cc, p1, p2, cv::Scalar(0, 215, 255, 255), 1);
#endif
					cv::LineIterator it(sinParts, p1, p2, 4);
					for (int n = 0; n < it.count; n++, ++it)
					{
						if (sinParts.ptr<uint8_t>(it.pos().y)[it.pos().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 > 2.1)
						break;
				}
				//没确定出元件间距一般为结尾或单个元件，继续从下一个起点计算弦长并开始追踪
				if (dChordL <= 2.1) {
					continue;
				}
				//顺时针(是否并行取决于在windows下运行还是树莓派上)
				{
					//追踪中心
					cv::Point2f trackCenter = cv::Point2f(startCenter.x, startCenter.y);
					//追踪角度、半径
					double trackAngle = startAngle, trackRadius = startRadius;
					//元件本身所占角度
					double trackOffset = dOffset;
					//元件间间距
					double partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
					//开始追踪
					bool trackEnd = true;
					do
					{
						bool found = true; bool trayEnd = false;
						std::vector<Track> vParts;
						for (double t = trackAngle + (trackOffset + partDist - trackOffset / 12.0); t < trackAngle + (trackOffset + partDist - trackOffset / 12.0) + trackOffset / 6.0; t += dMinorStep)
						{
							cv::Point2f predicPos;
							predicPos.x = reelCenter.x + (float)trackRadius*(float)cos((trackAngle + (trackOffset + partDist))*c);
							predicPos.y = reelCenter.y + (float)trackRadius*(float)sin((trackAngle + (trackOffset + partDist))*c);
							//如果追踪到图像外则追踪终止
							if (cvRound(predicPos.x) < 0 || (cvRound(predicPos.x) > X - 1) || cvRound(predicPos.y) < 0 || (cvRound(predicPos.y) > Y - 1)) {
								trayEnd = true;
								break;
							}
							//感兴趣区域(向外扩展了一个元件,防止中心定位出现偏差或者料盘本身变形导致的偏差)
							cv::Point2f predictBox[4];
							calcRotateRect(predicPos, (float)(trackAngle + (trackOffset + partDist)), (float)trackLength + (float)trackLength, (float)trackWidth + (float)trackWidth, predictBox);

							cv::RotatedRect r(predictBox[0], predictBox[1], predictBox[2]);
							cv::Rect rLimits = r.boundingRect()&cv::Rect(0, 0, X, Y);

							//获取感兴趣区域
							float matx[6];
							cv::Mat traceMat = getTrackMat(srcPrevS(rLimits).clone()
								, (trackAngle + (trackOffset + partDist)) + 90.0, fillVal, matx);

							//计算原图中的点在旋转后的位置(即在traceMat中的精确位置)
							cv::Point2f predictBoxR[4];
							for (int j = 0; j < 4; j++)
							{
								predictBoxR[j].x = matx[0] * (predictBox[j].x - (float)rLimits.x) + matx[1] * (predictBox[j].y - (float)rLimits.y) + matx[2];
								predictBoxR[j].y = matx[3] * (predictBox[j].x - (float)rLimits.x) + matx[4] * (predictBox[j].y - (float)rLimits.y) + matx[5];
							}
							//中点
							cv::Point2f predicPosR((predictBoxR[0].x + predictBoxR[1].x + predictBoxR[2].x + predictBoxR[3].x) / 4.0f,
								(predictBoxR[0].y + predictBoxR[1].y + predictBoxR[2].y + predictBoxR[3].y) / 4.0f);

							//理论区域
							cv::Rect tRec = cv::Rect(cv::Point(cvRound((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f),
								cvRound((predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f)),
								cv::Size(cvRound(trackLength*2.0), cvRound(trackWidth*4.0)))
								&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

							//高精度理论区域
							cv::Rect_<float> tRecF = cv::Rect_<float>(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f,
								(predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f),
								cv::Size2f((float)trackLength*2.0f, (float)trackWidth*4.0f))
								&cv::Rect_<float>(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

							//理论区域向外扩展(即predictBox范围)
							cv::Rect rr = cv::Rect(cv::Point(cvRound((double)predicPosR.x - trackLength*2.0),
								cvRound((double)predicPosR.y - trackWidth*4.0)), cv::Size(cvRound(trackLength*2.0*2.0),
									cvRound(trackWidth*4.0*2.0)))&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

							cv::Rect_<float> rrf = cv::Rect2f(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*4.0f) / 2.0f,
								(predicPosR.y*2.0f - (float)trackWidth*8.0f) / 2.0f), cv::Size2f((float)trackLength*4.0f, (float)trackWidth*8.0f))
								&cv::Rect2f(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

							//元件尺寸太小放大N倍处理，这样坐标会精细些,考虑元件的80%尺寸作为kernel，防止元件尺寸变化太大
							cv::Mat kernel = cv::Mat::ones(cv::Size(cv::max(cvRound((float)(trackLength*2.0) * coeff),
								cvRound((float)(trackWidth*4.0) * coeff)), cv::min(cvRound((float)(trackLength*2.0) * coeff),
									cvRound((float)(trackWidth*4.0) * coeff))), CV_32FC1);

							cv::Mat _traceMat = traceMat.clone();
							//放大
							if (coeff > 1.0f) {
								cv::resize(_traceMat, _traceMat, cv::Size(cvRound(traceMat.size().width * coeff), cvRound(traceMat.size().height * coeff)));
							}

							//计算最大值(当_traceMat尺寸小于kernel会报错)
							cv::Mat dst;
							cv::filter2D(_traceMat, dst, CV_32F, kernel);

							//归一化
							cv::Mat mmRescaling;
							cv::normalize(dst, mmRescaling, 1.0, 0.0, cv::NORM_MINMAX);

							//模板匹配做辅助判断,为了尽量避免定位出错
							cv::Mat _tplMat;
							tplMat.convertTo(_tplMat, CV_32FC1);
							if (coeff > 1.0f) {
								cv::resize(_tplMat, _tplMat, cv::Size(), coeff, coeff);
							}
							//防止报错
							if (_tplMat.cols > _traceMat.cols || _tplMat.rows > _traceMat.rows) {
								return FUNC_CANNOT_CALC;
							}
							//考虑并行计算两个模板结果
							cv::Mat tplResult0;
							cv::matchTemplate(_traceMat, _tplMat, tplResult0, cv::TM_SQDIFF_NORMED);

							int modx = _tplMat.cols % 2, mody = _tplMat.rows % 2;
							cv::Mat tplResultMap;
							cv::copyMakeBorder(tplResult0, tplResultMap, (_tplMat.rows - mody) / 2, _traceMat.rows - tplResult0.rows - (_tplMat.rows - mody) / 2,
								(_tplMat.cols - modx) / 2, _traceMat.cols - tplResult0.cols - (_tplMat.cols - modx) / 2, cv::BORDER_REPLICATE);

							//减去模板匹配的结果
							mmRescaling -= tplResultMap;
							//非极大值抑制
							cv::Mat mask;
							cv::dilate(mmRescaling, mask, cv::Mat());
							cv::compare(mmRescaling, mask, mask, cv::CMP_GE);

							cv::Mat non_plateau_mask;
							cv::erode(mmRescaling, non_plateau_mask, cv::Mat());
							cv::compare(mmRescaling, non_plateau_mask, non_plateau_mask, cv::CMP_GT);
							cv::bitwise_and(mask, non_plateau_mask, mask);

							//去掉分数过低的
							mask &= cv::Mat(mmRescaling > 0.36);
							//限定区域(mmRescaling范围内)
							cv::Rect _rr = cv::Rect(cvRound(rr.x*coeff), cvRound(rr.y*coeff), cvRound(rr.width*coeff), cvRound(rr.height*coeff));

							//候选元件位置
							std::vector<cv::Point> candidates;
							cv::findNonZero(mask(_rr), candidates);

							//过滤
							std::vector<Track> _vParts;
							for (auto&candidate : candidates) {
								cv::Point pt(candidate.x + _rr.x, candidate.y + _rr.y);
								float confidence = mmRescaling.ptr<float>(pt.y)[pt.x];
								if (confidence > 0.5f) {
									_vParts.push_back(Track(0, 0, confidence, cv::Point2f((float)pt.x, (float)pt.y), std::vector<cv::Point2f>()));
								}
							}

							//目标元件在小图中的位置
							cv::Point2f maxLox;
							//元件位置判断
							if (_vParts.size() <= 0) {
								//大概率终止
								trayEnd = true;
							}
							else if (_vParts.size() == 1) {
								//有可能会出错
								maxLox = cv::Point2f(_vParts[0].Pos.x / coeff, _vParts[0].Pos.y / coeff);
								if (tRecF.contains(maxLox)) {
									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
								}
								else {
									//这里负责处理意外情况（极大可能是元件偏离过多或者料盘中心定位不准确导致的）,
									//采用距离理论位置最近的点(两种方式都失效的概率比较低，如果真的失效那就听天由命吧)
									cv::Mat _mmRescaling, _tplResultMap;
									_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

									//累加的方式
									double maxVal; cv::Point maxLoc;
									cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
									maxLoc += _rr.tl();

									//模板匹配的方式
									double minVal; cv::Point minLoc;
									cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
									minLoc += _rr.tl();

									std::vector<Track> __vParts;
									__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
										cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

									__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
										cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

									//排序
									std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

									//在小图中的位置
									maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);

									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
									for (int j = 0; j < 4; j++)
									{
										cv::line(cc, predictBox[j], predictBox[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
									}
#endif
								}
							}
							else {
								//存在多个峰值,先判断分数最高是否位于理论位置
								std::sort(_vParts.begin(), _vParts.end(), std::greater<Track>());
								for (auto&_vPart : _vParts) {
									maxLox = cv::Point2f(_vPart.Pos.x / coeff, _vPart.Pos.y / coeff);
									if (tRecF.contains(maxLox)) {
										//计算旋转前的坐标（即匹配的最终坐标）
										float realX = 0.0f, realY = 0.0f;
										realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
										realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

										//外包矩形顶点
										cv::Point2f pts[4];
										calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

										//
										std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
										vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
										break;
									}
								}
								//如果不在则选取距离理论位置最近的
								if (vParts.empty()) {
									//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）
									//,采用距离理论位置最近的点(两种方式都失效的概率比较低)
									cv::Mat _mmRescaling, _tplResultMap;
									_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

									//累加的方式
									double maxVal; cv::Point maxLoc;
									cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
									maxLoc += _rr.tl();

									//模板匹配的方式
									double minVal; cv::Point minLoc;
									cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
									minLoc += _rr.tl();

									std::vector<Track> __vParts;
									__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
										cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

									__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
										cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

									//排序
									std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

									//在小图中的位置
									maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);

									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
									for (int j = 0; j < 4; j++)
									{
										cv::line(cc, predictBox[j], predictBox[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
									}
#endif
								}
							}
							if (!vParts.empty()) {
								cv::Rect tRec_ = cv::Rect(cv::Point(cvFloor((((float)maxLox.x)*2.0f - (float)trackLength*2.0f) / 2.0f),
									cvFloor((((float)maxLox.y)*2.0f - (float)trackWidth*4.0f) / 2.0f)),
									cv::Size(cvRound(trackLength*2.0) + 2, cvRound(trackWidth*4.0) + 2))
									&cv::Rect(0, 0, traceMat.cols, traceMat.rows);
								//当作一种辅助手段，无需设置太严格
								double dmax;
								cv::minMaxLoc(traceMat(tRec_).clone(), NULL, &dmax);
								if (dmax < 0.7*taMaxGray) {
									trayEnd = true;
								}
							}
							break;
						}
						//追踪终止，选取下一个起点
						if (trayEnd) {
							break;
						}
						//更新位置
						trackCenter = cv::Point2f(vParts[0].Pos.x, vParts[0].Pos.y);
						//更新扫描半径
						trackRadius = cv::norm(trackCenter - reelCenter);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - (double)reelCenter.y, (double)trackCenter.x - (double)reelCenter.x) * 180.0 / PI;
						//更新偏移量(元件角度大小)
						trackOffset = (2 * asin(2 * trackLength / (2 * trackRadius))) * 180.0 / PI;
						//更新元件间角度
						partDist = (2 * asin(dChordL / (2 * trackRadius))) * 180.0 / PI;
						//追踪到了重复的元件
						if ((trackCenter.x<0 || trackCenter.x>X - 1 ||
							trackCenter.y<0 || trackCenter.y>Y - 1) || trackMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] == 255) {
							found = false;
						}
						else {
							//计算元件位置
							cv::Point2f pts[4];
							calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);
							//标记计数
							lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;
							//标记为已追踪过
							std::vector<cv::Point> vT = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
							cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
							//用于显示
							cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
#ifdef _DEBUG
							for (int j = 0; j < 4; j++)
							{
								cv::line(cc, pts[j], pts[(j + 1) % 4], cv::Scalar(14, 173, 238, 255), 1);
							}
#endif
						}
						//清空下一个
						vParts.resize(0);
						//跳过执行
						if (killProcessID == 0) {
							logger.t("eyemCountObjectIrregularPartsE 追踪阶段被跳过执行...");
							found = false;
						}
						trackEnd = (!found);
					} while (!trackEnd);
				}

				//逆时针
				{
					//追踪起点
					cv::Point2f trackCenter(startCenter.x, startCenter.y);
					//追踪角度、半径
					double trackAngle = startAngle, trackRadius = startRadius;
					//元件本身角度
					double trackOffset = dOffset;
					//元件间间距
					double partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
					//开始追踪
					bool trackEnd = true;
					//
					do
					{
						bool found = true; bool trayEnd = false;
						std::vector<Track> vParts;
						for (double t = trackAngle - (trackOffset + partDist - trackOffset / 12.0); t > trackAngle - (trackOffset + partDist - trackOffset / 12.0) - trackOffset / 6.0; t -= dMinorStep)
						{
							cv::Point2f predicPos;
							predicPos.x = reelCenter.x + (float)trackRadius*(float)cos((trackAngle - (trackOffset + partDist))*c);
							predicPos.y = reelCenter.y + (float)trackRadius*(float)sin((trackAngle - (trackOffset + partDist))*c);
							//如果追踪到图像外追踪终止
							if (cvRound(predicPos.x) < 0 || (cvRound(predicPos.x) > X - 1) || cvRound(predicPos.y) < 0 || (cvRound(predicPos.y) > Y - 1)) {
								trayEnd = true;
								break;
							}
							//感兴趣区域(向外扩展了一个元件,防止中心定位出现偏差或者料盘本身变形导致的偏差)
							cv::Point2f predicBox[4];
							calcRotateRect(predicPos, (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, predicBox);

							cv::RotatedRect r(predicBox[0], predicBox[1], predicBox[2]);
							cv::Rect rLimits = r.boundingRect()&cv::Rect(0, 0, X, Y);

							//获取感兴趣区域
							float matx[6];
							cv::Mat traceMat = getTrackMat(srcPrevS(rLimits).clone()
								, (trackAngle - (trackOffset + partDist)) + 90.0, fillVal, matx);

							//计算原图中的点在旋转后的位置(即在traceMat中的精确位置)
							cv::Point2f predictBoxR[4];
							for (int j = 0; j < 4; j++)
							{
								predictBoxR[j].x = matx[0] * (predicBox[j].x - (float)rLimits.x) + matx[1] * (predicBox[j].y - (float)rLimits.y) + matx[2];
								predictBoxR[j].y = matx[3] * (predicBox[j].x - (float)rLimits.x) + matx[4] * (predicBox[j].y - (float)rLimits.y) + matx[5];
							}
							//中点
							cv::Point2f predicPosR((predictBoxR[0].x + predictBoxR[1].x + predictBoxR[2].x + predictBoxR[3].x) / 4.0f,
								(predictBoxR[0].y + predictBoxR[1].y + predictBoxR[2].y + predictBoxR[3].y) / 4.0f);

							//理论区域
							cv::Rect tRec = cv::Rect(cv::Point(cvRound((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f),
								cvRound((predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f)),
								cv::Size(cvRound(trackLength*2.0), cvRound(trackWidth*4.0)))
								&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

							//高精度理论区域
							cv::Rect_<float> tRecF = cv::Rect_<float>(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*2.0f) / 2.0f,
								(predicPosR.y*2.0f - (float)trackWidth*4.0f) / 2.0f),
								cv::Size2f((float)trackLength*2.0f, (float)trackWidth*4.0f))
								&cv::Rect_<float>(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

							//理论区域向外扩展(即predictBox范围)
							cv::Rect rr = cv::Rect(cv::Point(cvRound((double)predicPosR.x - trackLength*2.0),
								cvRound((double)predicPosR.y - trackWidth*4.0)), cv::Size(cvRound(trackLength*2.0*2.0),
									cvRound(trackWidth*4.0*2.0)))&cv::Rect(0, 0, traceMat.cols, traceMat.rows);

							cv::Rect_<float> rrf = cv::Rect2f(cv::Point2f((predicPosR.x*2.0f - (float)trackLength*4.0f) / 2.0f,
								(predicPosR.y*2.0f - (float)trackWidth*8.0f) / 2.0f), cv::Size2f((float)trackLength*4.0f, (float)trackWidth*8.0f))
								&cv::Rect2f(0.0f, 0.0f, (float)traceMat.cols, (float)traceMat.rows);

							//元件尺寸太小放大N倍处理，这样坐标会精细些,元件的80%尺寸作为kernel，防止元件尺寸变化太大
							cv::Mat kernel = cv::Mat::ones(cv::Size(cv::max(cvRound((float)(trackLength*2.0) * coeff),
								cvRound((float)(trackWidth*4.0) * coeff)), cv::min(cvRound((float)(trackLength*2.0) * coeff),
									cvRound((float)(trackWidth*4.0) * coeff))), CV_32FC1);
							cv::Mat _traceMat = traceMat.clone();
							//放大
							if (coeff > 1.0f) {
								cv::resize(_traceMat, _traceMat, cv::Size(cvRound(traceMat.size().width * coeff), cvRound(traceMat.size().height * coeff)));
							}
							//计算最大值(当_traceMat尺寸小于kernel会报错)
							cv::Mat dst;
							cv::filter2D(_traceMat, dst, CV_32F, kernel);
							//归一化
							cv::Mat mmRescaling;
							cv::normalize(dst, mmRescaling, 1.0, 0.0, cv::NORM_MINMAX);

							//模板匹配,为了尽量避免定位出错
							cv::Mat _tplMat;
							tplMat.convertTo(_tplMat, CV_32FC1);
							if (coeff > 1.0f) {
								cv::resize(_tplMat, _tplMat, cv::Size(), coeff, coeff);
							}
							//防止报错
							if (_tplMat.cols > _traceMat.cols || _tplMat.rows > _traceMat.rows) {
								return FUNC_CANNOT_CALC;
							}
							//考虑并行计算两个模板结果
							cv::Mat tplResult0;
							cv::matchTemplate(_traceMat, _tplMat, tplResult0, cv::TM_SQDIFF_NORMED);

							int modx = _tplMat.cols % 2, mody = _tplMat.rows % 2;
							cv::Mat tplResultMap;
							cv::copyMakeBorder(tplResult0, tplResultMap, (_tplMat.rows - mody) / 2, _traceMat.rows - tplResult0.rows - (_tplMat.rows - mody) / 2,
								(_tplMat.cols - modx) / 2, _traceMat.cols - tplResult0.cols - (_tplMat.cols - modx) / 2, cv::BORDER_REPLICATE);

							//减去模板匹配的结果
							mmRescaling -= tplResultMap;
							//非极大值抑制
							cv::Mat mask;
							cv::dilate(mmRescaling, mask, cv::Mat());
							cv::compare(mmRescaling, mask, mask, cv::CMP_GE);

							cv::Mat non_plateau_mask;
							cv::erode(mmRescaling, non_plateau_mask, cv::Mat());
							cv::compare(mmRescaling, non_plateau_mask, non_plateau_mask, cv::CMP_GT);
							cv::bitwise_and(mask, non_plateau_mask, mask);

							//去掉分数过低的
							mask &= cv::Mat(mmRescaling > 0.36);
							//限定区域(mmRescaling范围内)
							cv::Rect _rr = cv::Rect(cvRound(rr.x*coeff), cvRound(rr.y*coeff), cvRound(rr.width*coeff), cvRound(rr.height*coeff));
							//候选元件位置
							std::vector<cv::Point> candidates;
							cv::findNonZero(mask(_rr), candidates);

							//过滤
							std::vector<Track> _vParts;
							for (auto&candidate : candidates) {
								cv::Point pt(candidate.x + _rr.x, candidate.y + _rr.y);
								float confidence = mmRescaling.ptr<float>(pt.y)[pt.x];
								if (confidence > 0.5f) {
									_vParts.push_back(Track(0, 0, confidence, cv::Point2f((float)pt.x, (float)pt.y), std::vector<cv::Point2f>()));
								}
							}
							//目标元件在小图中的位置
							cv::Point2f maxLox;
							//元件位置判断
							if (_vParts.size() <= 0) {
								//大概率终止
								trayEnd = true;
							}
							else if (_vParts.size() == 1) {
								maxLox = cv::Point2f(_vParts[0].Pos.x / coeff, _vParts[0].Pos.y / coeff);
								//有可能会出错，当靠的太近可能只存在一个峰值
								if (tRecF.contains(maxLox)) {
									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle + (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
								}
								else {
									//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）,采用距离理论位置最近的点(两种方式都失效的概率比较低)
									cv::Mat _mmRescaling, _tplResultMap;
									_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

									//累加的方式
									double maxVal; cv::Point maxLoc;
									cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
									maxLoc += _rr.tl();

									//模板匹配的方式
									double minVal; cv::Point minLoc;
									cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
									minLoc += _rr.tl();

									std::vector<Track> __vParts;
									__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
										cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

									__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
										cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

									//排序
									std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

									//小图中的定位坐标
									maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);
									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
									for (int j = 0; j < 4; j++)
									{
										cv::line(cc, predicBox[j], predicBox[(j + 1) % 4], cv::Scalar(0, 0, 238, 255), 1);
									}
#endif
								}
							}
							else {
								//存在定位出错的可能性,先判断分数最高是否位于理论位置
								std::sort(_vParts.begin(), _vParts.end(), std::greater<Track>());
								for (auto&_vPart : _vParts) {
									maxLox = cv::Point2f(_vPart.Pos.x / coeff, _vPart.Pos.y / coeff);
									if (tRecF.contains(maxLox)) {
										//计算旋转前的坐标（即匹配的最终坐标）
										float realX = 0.0f, realY = 0.0f;
										realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
										realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

										//外包矩形顶点
										cv::Point2f pts[4];
										calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

										//
										std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
										vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
										break;
									}
								}
								//如果不在则选取距离理论位置最近的
								if (vParts.empty()) {
									//这里负责处理意外情况（极大可能是元件偏离过多或者中心定位不准确）,采用距离理论位置最近的点(两种方式都失效的概率比较低)
									cv::Mat _mmRescaling, _tplResultMap;
									_mmRescaling = mmRescaling.clone(); _tplResultMap = tplResultMap.clone();

									//累加的方式
									double maxVal; cv::Point maxLoc;
									cv::minMaxLoc(_mmRescaling(_rr), NULL, &maxVal, NULL, &maxLoc);
									maxLoc += _rr.tl();

									//模板匹配的方式
									double minVal; cv::Point minLoc;
									cv::minMaxLoc(_tplResultMap(_rr), &minVal, NULL, &minLoc, NULL);
									minLoc += _rr.tl();

									std::vector<Track> __vParts;
									__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)maxLoc.x, (float)maxLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
										cv::Point2f((float)maxLoc.x, (float)maxLoc.y), std::vector<cv::Point2f>()));

									__vParts.push_back(Track(0, 0, cv::norm(cv::Point2f((float)minLoc.x, (float)minLoc.y) - cv::Point2f(floorf((float)_traceMat.cols / 2.0f), floorf((float)_traceMat.rows / 2.0f))),
										cv::Point2f((float)minLoc.x, (float)minLoc.y), std::vector<cv::Point2f>()));

									//排序
									std::sort(__vParts.begin(), __vParts.end(), std::less<Track>());

									//小图中的位置
									maxLox = cv::Point2f(__vParts[0].Pos.x / coeff, __vParts[0].Pos.y / coeff);
									//计算旋转前的坐标（即匹配的最终坐标）
									float realX = 0.0f, realY = 0.0f;
									realX = (float)rLimits.tl().x + ((maxLox.x - matx[2])*matx[4] - (maxLox.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
									realY = (float)rLimits.tl().y + ((maxLox.x - matx[2])*matx[3] - (maxLox.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);

									//外包矩形顶点
									cv::Point2f pts[4];
									calcRotateRect(cv::Point2f(realX, realY), (float)(trackAngle - (trackOffset + partDist)), (float)trackLength*2.0f, (float)trackWidth*2.0f, pts);

									//
									std::vector<cv::Point2f> vRect(pts, pts + sizeof(pts) / sizeof(cv::Point2f));
									vParts.push_back(Track(0, 0, 0, cv::Point2f(realX, realY), vRect));
#ifdef _DEBUG
									for (int j = 0; j < 4; j++)
									{
										cv::line(cc, predicBox[j], predicBox[(j + 1) % 4], cv::Scalar(0, 0, 238, 255), 1);
									}
#endif
								}
							}

							if (!vParts.empty()) {
								cv::Rect tRec_ = cv::Rect(cv::Point(cvFloor((((float)maxLox.x)*2.0f - (float)trackLength*2.0f) / 2.0f),
									cvFloor((((float)maxLox.y)*2.0f - (float)trackWidth*4.0f) / 2.0f)),
									cv::Size(cvRound(trackLength*2.0) + 2, cvRound(trackWidth*4.0) + 2))
									&cv::Rect(0, 0, traceMat.cols, traceMat.rows);
								//当作一种辅助手段，无需设置太严格
								double dmax;
								cv::minMaxLoc(traceMat(tRec_).clone(), NULL, &dmax);
								if (dmax < 0.7*taMaxGray) {
									trayEnd = true;
								}
							}
							break;
						}
						//接着下一个起点
						if (trayEnd) {
							break;
						}
						//更新位置
						trackCenter = cv::Point2f(vParts[0].Pos.x, vParts[0].Pos.y);
						//更新扫描半径
						trackRadius = cv::norm(trackCenter - reelCenter);
						//更新扫描角度
						trackAngle = atan2((double)trackCenter.y - (double)reelCenter.y, (double)trackCenter.x - (double)reelCenter.x) * 180.0 / PI;
						//更新偏移量(元件角度大小)
						trackOffset = (2.0 * asin(2.0 * trackLength / (2.0 * trackRadius))) * 180.0 / PI;
						//更新元件间角度
						partDist = (2.0 * asin(dChordL / (2.0 * trackRadius))) * 180.0 / PI;
						//追踪到了重复的元件
						if ((trackCenter.x<0 || trackCenter.x>X - 1 ||
							trackCenter.y<0 || trackCenter.y>Y - 1) || trackMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] == 255) {
							found = false;
						}
						else {
							//计算元件位置
							cv::Point2f pts[4];
							calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);
							//标记计数
							lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;
							//标记为已追踪过
							std::vector<cv::Point> vT = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
							cv::fillConvexPoly(trackMat, vT, cv::Scalar(255));
							//用于显示
							cv::circle(cc, trackCenter, 2, cv::Scalar(0, 255, 0, 255), 1);
#ifdef _DEBUG
							for (int j = 0; j < 4; j++)
							{
								cv::line(cc, pts[j], pts[(j + 1) % 4], cv::Scalar(102, 205, 0, 255), 1);
							}
#endif
						}
						//继续下一个起点
						vParts.resize(0);
						//跳过执行
						if (killProcessID == 0) {
							logger.t("eyemCountObjectIrregularParts 追踪阶段被跳过执行...");
							found = false;
						}
						trackEnd = (!found);
					} while (!trackEnd);
				}
			}
			//标记料盘编号
			//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 reelNum = cv::countNonZero(lbMat);
			std::string text = std::to_string(i + 1) + ": Reel Number = ";
			text += std::to_string(reelNum);
			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] = reelNum;
			//释放资源
			delete[] ucpTrackLabel;
			ucpTrackLabel = NULL;
		}
	}
	//输出结果
	const int SizeConst = 4;
	//<输出计数结果标记图像
	{
		for (int i = 0; i < SizeConst; i++) {
			ipReelNum[i] = trayNum[i];
		}

		tpDstImg->iWidth = cc.cols; tpDstImg->iHeight = cc.rows; tpDstImg->iDepth = cc.depth(); tpDstImg->iChannels = cc.channels();

		//内存尺寸
		int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);

		//分配内存
		tpDstImg->vpImage = (uint8_t *)malloc(_Size);
		if (NULL == tpDstImg->vpImage)
			return FUNC_NOT_ENOUGH_MEM;
		memset(tpDstImg->vpImage, 0, _Size);

		//拷贝数据
		memcpy(tpDstImg->vpImage, cc.data, _Size);
	}
	return FUNC_OK;
}

int	eyemCountObjectIrregularPartsE(EyemImage tpImage, EyemRect tpRoi, const char *fileName, const char *ccTplName, IntPtr hModelID, int *ipReelNum, EyemImage *tpDstImg)
{
	cv::Mat src = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();

	//判断文件是否存在
	if (src.empty() || NULL == hModelID) {
		return FUNC_IMAGE_NOT_EXIST;
	}

	//跳过执行
	if (killProcessID == 0) {
		logger.t("eyemCountObjectIrregularPartsE 初始阶段被跳过执行...");
		return FUNC_CANNOT_CALC;
	}

	double begin0 = (double)cv::getTickCount();

	//转单通道图像
	if (src.channels() != 1)
		cv::cvtColor(src, src, cv::COLOR_BGR2GRAY);

	//图像裁剪
	src = src(cv::Rect(tpRoi.iXs, tpRoi.iYs, tpRoi.iWidth, tpRoi.iHeight)).clone();

	//图像尺寸
	int X = src.cols, Y = src.rows;

	//加载模板
	std::vector<EyemModelID> *tpModelIDs = reinterpret_cast<std::vector<EyemModelID>*>(hModelID);

	cv::Mat _tplMat; double matchDeg = 0.0;
	//
	for (std::vector<EyemModelID>::iterator it = tpModelIDs->begin(); it != tpModelIDs->end(); ++it) {
		if (std::strcmp((*it).lpszName, ccTplName) == 0)
		{
			EyemModelID tpModelID = (*it);

			matchDeg = tpModelID.dMatchDeg;
			_tplMat = cv::Mat(tpModelID.iHeight, tpModelID.iWidth, CV_8UC1, tpModelID.vpImage);
			break;
		}
	}

	//模板文件不存在
	if (_tplMat.empty())
		return FUNC_CANNOT_CALC;

	//模板反转
	cv::Mat tplMat;
	cv::bitwise_not(_tplMat, tplMat);

	//模板尺寸
	int tplWidth, tplHeight;
	tplWidth = tplMat.cols, tplHeight = tplMat.rows;

	//去除局部量斑影响（默认亮斑尺寸不会大于15个像素）
	cv::Mat srcTmp;
	cv::morphologyEx(src, srcTmp, cv::MORPH_ERODE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(15, 15)));

	//去除黑斑影响
	int m = cvRound(cv::mean(src)[0]);
	srcTmp.forEach<uint16_t>([&](uint16_t& pixel, const int *pos)->void {
		pixel = pixel == 0 ? m : pixel;
	});

	//图像增强
	double min, max;
	cv::minMaxLoc(srcTmp, &min, &max);
	src.convertTo(src, CV_64FC1);

	src -= min;
	src /= (max - min);
	src *= 65535;
	src.convertTo(src, CV_16UC1);

	//转8位灰度图
	cv::Mat src8U;
	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 backT = 15 * (maxIdx[0] - 2);

	//去掉背景
	src8U.forEach<uint8_t>([&](uint8_t& pixel, const int *pos)->void {
		pixel = pixel >= backT ? backT : pixel;
	});

	//增强到目标亮度，用于显示
	cc += cv::Scalar((162 - backT), (162 - backT), (162 - backT));

	//去掉干扰
	cv::Mat binary, srcPrev;
	cv::bitwise_not(src8U, srcPrev);

	//计数图像
	cv::Mat lbMat(Y, X, CV_8UC1, cv::Scalar(0));

	//测试用，根据模板尺寸顶帽处理，去掉中间料盘
	int minPart = cv::min(tplWidth, tplHeight);

	cv::Mat srcPrevWithMask(Y, X, CV_8UC1);

	srcPrev.copyTo(srcPrevWithMask);

	if (minPart < 12) {

		cv::Mat srcPrevEx;
		cv::morphologyEx(srcPrev, srcPrevEx, cv::MORPH_TOPHAT, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(minPart, minPart)));

		//
		cv::Mat srcPrevExb;
		cv::threshold(srcPrevEx, srcPrevExb, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);

		//膨胀
		cv::morphologyEx(srcPrevExb, srcPrevExb, cv::MORPH_DILATE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(minPart, minPart)));

		//去掉盘本身的影响
		srcPrevWithMask = cv::Scalar(255 - backT);
		srcPrev.copyTo(srcPrevWithMask, srcPrevExb);
	}

	//使用大料算法（模板匹配方式）
	cv::threshold(srcPrev, binary, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);

	//去掉小于5个像素的干扰
	cv::Mat labels0, stats0, centroids0;
	int nccomps0 = cv::connectedComponentsWithStats(binary, labels0, stats0, centroids0, 4);
	//过滤连通域面积及长/宽比例不符合的,允许50%误差
	std::vector<uchar> colors0(nccomps0 + 1, 0);
	for (int i = 1; i < nccomps0; i++) {
		colors0[i] = 255;
		if ((stats0.ptr<int>(i)[cv::CC_STAT_AREA] < 10))
		{
			colors0[i] = 0;
		}
	}
	//过滤
	cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
		for (int y = range.start; y < range.end; y++)
		{
			uint8_t *ptrRow = binary.ptr<uint8_t>(y);
			for (int x = 0; x < X; x++)
			{
				int label = labels0.ptr<int>(y)[x];
				CV_Assert(0 <= label && label <= nccomps0);
				ptrRow[x] = colors0[label];
			}
		}
	});

	cv::Mat srcPrevEx0;
	//连接
	cv::morphologyEx(binary, srcPrevEx0, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(95, 95)));

	//定位料盘中心
	std::vector<std::vector<cv::Point>> contours;
	cv::findContours(srcPrevEx0, contours, cv::RETR_TREE, cv::CHAIN_APPROX_NONE);

	cv::Mat srcPrevEx1 = cv::Mat::zeros(src8U.size(), CV_8UC1);
	//填充料盘
	for (int i = 0; i < contours.size(); i++)
	{
		cv::drawContours(srcPrevEx1, contours, i, cv::Scalar(255), -1);
	}

	cv::Mat image = srcPrevEx1.clone();

	//取中间部分，避免因料盘散开而导致中心定位错误（如果没有就选取外面）
	srcPrevEx1 -= srcPrevEx0;

	//
	cv::morphologyEx(srcPrevEx1, srcPrevEx1, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(95, 95)));

	//获取最大轮廓
	cv::findContours(srcPrevEx1, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);

	if (contours.size() <= 0)
	{
		cv::findContours(image, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
	}

	std::vector<cv::Point> contourMax = contours[0]; double contourMaxArea = cv::contourArea(contourMax);
	for (int i = 1; i < contours.size(); i++)
	{
		double contourArea = cv::contourArea(contours[i]);
		if (contourArea > contourMaxArea)
		{
			contourMax = contours[i];
			contourMaxArea = contourArea;
		}
	}

	//面积小于50000判断不是中心
	if (contourMaxArea < 50000) {
		cv::findContours(image, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
		//最大轮廓
		for (int i = 1; i < contours.size(); i++)
		{
			double contourArea = cv::contourArea(contours[i]);
			if (contourArea > contourMaxArea)
			{
				contourMax = contours[i];
				contourMaxArea = contourArea;
			}
		}
	}

	//质心
	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);

	//计算料盘范围
	cv::findContours(image, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);

	contourMax = contours[0]; contourMaxArea = cv::contourArea(contourMax);
	for (int i = 1; i < contours.size(); i++)
	{
		double contourArea = cv::contourArea(contours[i]);
		if (contourArea > contourMaxArea)
		{
			contourMax = contours[i];
			contourMaxArea = contourArea;
		}
	}

	//去掉料盘中心
	cv::circle(srcPrevWithMask, cv::Point(reelCenter), 150, cv::Scalar(255 - backT), -1);

	cv::Rect rec = cv::boundingRect(contourMax);

	//顶点坐标
	cv::Point tl, br, tr, bl;
	tl = cv::Point(cv::max(rec.tl().x - 35, 0), cv::max(rec.tl().y - 35, 0)); br = cv::Point(cv::min(rec.br().x + 35, Y), cv::min(rec.br().y + 35, Y));
	tr = cv::Point(br.x, tl.y); bl = cv::Point(tl.x, br.y);

	//用八个方向的模板进行模板匹配(模板匹配的方式对于发生形变的器件效果不好,实在不行就用八个方向，增加起点数量来弥补追踪终止导致的偏差)
	const float icvDirections[4] = { 0 , 90 , 180 , -90 };

	//用以计算元件中心
	const int icvDirectionDeltas[4][2] = { { tplWidth / 2,tplHeight / 2 },{ tplHeight / 2,tplWidth / 2 },{ tplWidth / 2,tplHeight / 2 },\
	{ tplHeight / 2,tplWidth / 2 } };

	//用于计数
	cv::Mat matchParts(Y, X, CV_8UC1, cv::Scalar(0));

	cv::parallel_for_(cv::Range(0, 4), [&](const cv::Range& range)->void {
		for (int tpl = range.start; tpl < range.end; tpl++)
		{
			//模板匹配(仅处理料盘区域以提高速度)
			cv::Mat tplResult0;
			cv::matchTemplate(srcPrevWithMask(cv::Rect(tl, br)), getTplMat(tplMat, icvDirections[tpl], (255 - backT)), tplResult0, cv::TM_CCOEFF_NORMED);

			//分数大于一定分数才当作元件处理
			tplResult0 = cv::Mat(tplResult0 > matchDeg);

			cv::Point quard[4]{ cv::Point(tplResult0.cols,0),cv::Point(0,0),cv::Point(0,tplResult0.rows),cv::Point(tplResult0.cols,tplResult0.rows) };

			std::vector<cv::Point> pt = { cv::Point(tplResult0.cols / 2,tplResult0.rows / 2),quard[tpl], quard[(tpl + 1) % 4] };

			std::vector<std::vector<cv::Point>> pts;
			pts.push_back(pt);

			cv::Mat dirMask(tplResult0.size(), CV_8UC1, cv::Scalar(0));

			cv::drawContours(dirMask, pts, 0, cv::Scalar(255), -1);

			//除去非必要部分
			cv::bitwise_and(tplResult0, dirMask, tplResult0);

			//连通域分析
			cv::Mat labels, stats, centroids;
			int nccomps = cv::connectedComponentsWithStats(tplResult0, labels, stats, centroids);

			for (int i = 1; i < nccomps; i++) {
				cv::Point matchPt(cvRound(centroids.ptr<double>(i)[0]) + icvDirectionDeltas[tpl][0] + tl.x, \
					cvRound(centroids.ptr<double>(i)[1]) + icvDirectionDeltas[tpl][1] + tl.y);
				matchParts.ptr<uint8_t>(matchPt.y)[matchPt.x] = 255;
			}
		}
	});

	//旋转图像,计算另外四个方向的起点
	float matx[6];
	cv::Mat srcPrev45 = getTrackMat(srcPrevWithMask(cv::Rect(tl, br)), 45.0, 0, matx);

	/*cv::Mat showMat2;
	cv::cvtColor(srcPrev(cv::Rect(tl, br)), showMat2, cv::COLOR_GRAY2BGRA);*/

	cv::parallel_for_(cv::Range(0, 4), [&](const cv::Range& range)->void {
		for (int tpl = range.start; tpl < range.end; tpl++)
		{
			//模板匹配(仅处理料盘区域以提高速度)
			cv::Mat tplResult0;
			cv::matchTemplate(srcPrev45, getTplMat(tplMat, icvDirections[tpl], 0), tplResult0, cv::TM_CCOEFF_NORMED);

			//分数大于一定分数才当作元件处理
			tplResult0 = cv::Mat(tplResult0 > matchDeg);

			cv::Point quard[4]{ cv::Point(tplResult0.cols,0),cv::Point(0,0),cv::Point(0,tplResult0.rows),cv::Point(tplResult0.cols,tplResult0.rows) };

			std::vector<cv::Point> pt = { cv::Point(tplResult0.cols / 2,tplResult0.rows / 2),quard[tpl], quard[(tpl + 1) % 4] };

			std::vector<std::vector<cv::Point>> pts;
			pts.push_back(pt);

			cv::Mat dirMask(tplResult0.size(), CV_8UC1, cv::Scalar(0));

			cv::drawContours(dirMask, pts, 0, cv::Scalar(255), -1);

			//除去非必要部分
			cv::bitwise_and(tplResult0, dirMask, tplResult0);

			//连通域分析
			cv::Mat labels, stats, centroids;
			int nccomps = cv::connectedComponentsWithStats(tplResult0, labels, stats, centroids);

			for (int i = 1; i < nccomps; i++) {
				cv::Point matchPt(cvRound(centroids.ptr<double>(i)[0]) + icvDirectionDeltas[tpl][0], \
					cvRound(centroids.ptr<double>(i)[1]) + icvDirectionDeltas[tpl][1]);
				//转原图坐标
				cv::Point2f maxLoc;
				maxLoc.x = (float)tl.x + (((float)matchPt.x - matx[2])*matx[4] - ((float)matchPt.y - matx[5])*matx[1]) / (matx[0] * matx[4] - matx[3] * matx[1]);
				maxLoc.y = (float)tl.y + (((float)matchPt.x - matx[2])*matx[3] - ((float)matchPt.y - matx[5])*matx[0]) / (matx[1] * matx[3] - matx[4] * matx[0]);
				//记录位置
				matchParts.ptr<uint8_t>(cvRound(maxLoc.y))[cvRound(maxLoc.x)] = 255;
			}
		}
	});

	//计算初始起点
	std::vector<cv::Point> matchPts;
	cv::findNonZero(matchParts, matchPts);

#ifdef _DEBUG
	for (std::vector<cv::Point>::iterator itv = matchPts.begin(); itv != matchPts.end(); ++itv)
	{
		cv::drawMarker(cc, cv::Point((*itv).x, (*itv).y), cv::Scalar(0, 255, 0, 255));
	}
#endif

	///<追踪元件算法流程

	//标签图
	cv::Mat trackMat(Y, X, CV_8UC1, cv::Scalar(0));

	//追踪信息
	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;
		}
	};

	//计算元件间距
	double dChordL = .0;
	for (std::vector<cv::Point>::iterator itv = matchPts.begin(); itv != matchPts.end(); ++itv)
	{
		///<初始化追踪参数
		//追踪起点
		cv::Point2f startCenter((float)(*itv).x, (float)(*itv).y);
		//扫描步长
		const double dMinorStep = 0.1;
		//追踪长宽
		const double trackLength = (double)tplWidth / 2., trackWidth = (double)tplHeight / 4.;
		//起始扫描角度
		const double startAngle = atan2((double)startCenter.y - (double)reelCenter.y, (double)startCenter.x - (double)reelCenter.x) * 180 / PI;
		//起始扫描半径
		const double startRadius = cv::norm(startCenter - reelCenter);
		//偏移角度（元件尺寸）
		const double dOffset = (2 * asin(2 * trackLength / (2 * startRadius))) * 180. / PI;

		//初始搜索角度，用以确定元件间距(默认15度范围内存在元件)
		const double dScanRange = 15;

		//追踪元件间距(弦长，可以尽量避免因个别器件偏离导致的追踪中断)
		std::vector<Track> track4ChordL; bool expect = false;
		for (double t = startAngle + dOffset; t < startAngle + dOffset + dScanRange; t += dMinorStep)
		{
			float x = float(reelCenter.x + startRadius*cos(t*c));
			float y = float(reelCenter.y + startRadius*sin(t*c));

			cv::Point2f pts[4];
			calcRotateRect(cv::Point2f(x, y), (float)t, (float)trackLength, (float)trackWidth, pts);

			//计算极值
			double maxyyu; cv::Point2f trackCentert;
			findTrackModel(srcPrev, tplMat, 90.0 - (t + 180.0), trackWidth, pts, (255 - backT), false, maxyyu, trackCentert, cv::noArray());

			//匹配阈值
			if (maxyyu > matchDeg)
			{
				track4ChordL.push_back(Track(0, 0, maxyyu, (cv::Point)trackCentert, std::vector<cv::Point2f>()));

				if (!expect)
					expect = true;
			}
			if ((maxyyu < matchDeg) && expect)
				break;
		}

		//计算元件间距
		if (track4ChordL.size() != 0) {

			std::sort(track4ChordL.begin(), track4ChordL.end(), std::greater<Track>());

			cv::Point expectPos = track4ChordL[0].Pos;

			dChordL = 2.0 * startRadius*sin(((2.0 * asin((cv::norm(startCenter - cv::Point2f((float)expectPos.x, \
				(float)expectPos.y))) / (2.0 * startRadius))) * 180.0 / PI - dOffset)*PI / 180.0 / 2.0);

			//标记
			//cv::drawMarker(cc, cv::Point(expectPos.x, expectPos.y), cv::Scalar(0, 0, 255, 255), 0, 10);
		}
		else {
			//用先前的方式重新计算间距，因为耗时操作不会在这里,加上可以减少耗时但可能不一定准
		}

		//计算元件间距
		if (dChordL > 0) {
			break;
		}
	}

	//std::cout << "除追踪之外耗时：" << 1000 * (static_cast<double>(cv::getTickCount()) - begin0) / cv::getTickFrequency() << std::endl;

	//大于3个起点坐标排序
	if (matchPts.size() > 3) {

		std::vector<Track> tMatchPts;
		for (std::vector<cv::Point>::iterator itv = matchPts.begin(); itv != matchPts.end(); ++itv)
		{
			cv::Point2f startCenter((float)(*itv).x, (float)(*itv).y);

			tMatchPts.push_back(Track(0, 0, cv::norm(startCenter - reelCenter), cv::Point(startCenter), std::vector<cv::Point2f>()));
		}

		//按照距离排序
		std::sort(tMatchPts.begin(), tMatchPts.end(), std::greater<Track>());

		std::vector<cv::Point> sortedMatchPts;

		int len = cvRound((double)tMatchPts.size() / 2.0);
		for (int i = 0; i < len; i++)
		{
			int beforeidx = (len * 3 - i) % tMatchPts.size();

			int afteridx = (len * 3 + i) % tMatchPts.size();

			if (beforeidx == afteridx) {
				sortedMatchPts.push_back(tMatchPts[afteridx].Pos);
			}
			else {
				sortedMatchPts.push_back(tMatchPts[afteridx].Pos);
				sortedMatchPts.push_back(tMatchPts[beforeidx].Pos);
			}
		}
		//偶数个
		if (tMatchPts.size() % 2 == 0) {
			sortedMatchPts.push_back(tMatchPts[0].Pos);
		}

		//容器内容互换
		sortedMatchPts.swap(matchPts);
	}

	///<开始顺时针与逆时针两个方向追踪流程
	for (std::vector<cv::Point>::iterator itv = matchPts.begin(); itv != matchPts.end(); ++itv)
	{
		//跳过执行
		if (killProcessID == 0) {
			logger.t("eyemCountObjectIrregularPartsE 点料阶段被跳过执行...");
			break;
		}

		//追踪起点
		cv::Point2f startCenter((float)(*itv).x, (float)(*itv).y);

		//已作标记
		if (trackMat.ptr<uint8_t>((int)startCenter.y)[(int)startCenter.x] == 255)
			continue;

		//除去内圈干扰
		if (cv::norm(startCenter - reelCenter) < 150)
			continue;

		//计算元件区域
		cv::Point2f points[4];
		{
			double t = atan2((double)(*itv).y - reelCenter.y, (double)(*itv).x - reelCenter.x) * 180 / PI;

			const float trackLength = (float)tplWidth / 2.0f, trackWidth = (float)tplHeight / 4.0f;

			calcRotateRect(startCenter, (float)t, trackLength, trackWidth, points);
		}

		//增加判断，在模板匹配失效时候判断,可能匹配的不是元件
		cv::RotatedRect rt(points[0], points[1], points[2]);

		cv::Rect brt = rt.boundingRect()&cv::Rect(0, 0, X, Y);

		//判断为背景
		if (((float)cv::countNonZero(binary(brt)) / rt.size.area()) < 0.25) {
			continue;
		}

		//标记为已追踪过
		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));

		//标记计数
		lbMat.ptr<uint8_t>(cvRound(startCenter.y))[cvRound(startCenter.x)] = 255;

		//标记当前位置
		cv::drawMarker(cc, cv::Point((*itv).x, (*itv).y), cv::Scalar(0, 255, 0, 255), cv::MARKER_DIAMOND, 5);

		///<初始化追踪参数
		//扫描步长
		const double dMinorStep = 0.1;
		//追踪长宽
		const double trackLength = (double)tplWidth / 2., trackWidth = (double)tplHeight / 4.;
		//起始扫描角度
		const double startAngle = atan2((double)startCenter.y - (double)reelCenter.y, (double)startCenter.x - (double)reelCenter.x) * 180 / PI;
		//起始扫描半径
		const double startRadius = cv::norm(startCenter - reelCenter);
		//偏移角度（元件尺寸）
		const double dOffset = (2 * asin(2 * trackLength / (2 * startRadius))) * 180. / PI;

		//优化开关
#define OPTIMIZE_ON true

#if OPTIMIZE_ON

		//考虑作并行处理
		tbb::parallel_invoke(
			[&]
#endif
		{
			//< 顺时针追踪
			//追踪中心
			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];
			//开始追踪
			bool trackEnd = true;
			do
			{
				double begin0 = (double)cv::getTickCount();

				bool found = true;
				std::vector<Track> vParts;

				for (double t = trackAngle + (trackOffset / 2.0 + partDist + trackOffset / 3.0); t < trackAngle + \
					(trackOffset / 2.0 + partDist + trackOffset / 3.0) + trackOffset / 3.0; t += dMinorStep)
				{
					trackCenter.x = reelCenter.x + (float)trackRadius*(float)cos(t*c);
					trackCenter.y = reelCenter.y + (float)trackRadius*(float)sin(t*c);

					//计算旋转矩形
					calcRotateRect(trackCenter, (float)t, (float)trackLength, (float)trackWidth, pts);

					//模板匹配
					double maxyyu; cv::Point2f maxyyuloc;
					findTrackModel(srcPrev, tplMat, 90.0 - (t + 180.0), trackWidth, pts, (255 - backT), false, maxyyu, maxyyuloc, cv::noArray());

					//最小匹配结果
					if (maxyyu > 0.15)
					{
						//存放结果
						vParts.push_back(Track(0, 0, maxyyu, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), std::vector<cv::Point2f>()));
					}

					//测试标记
					//cv::drawMarker(cc, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), cv::Scalar(0, 165, 255, 255), 0, 5);
				}

				//如果为0大概率是背景
				if (vParts.size() <= 0)
					break;

				//更新切线方向位置,由于这个方向是元件间隙不会有太大偏差
				trackCenter = cv::Point2f((float)vParts[vParts.size() / 2].Pos.x, (float)vParts[vParts.size() / 2].Pos.y);

				//理论元件位置
				cv::Point2f trackCenterT(trackCenter.x, trackCenter.y);

				//更新扫描角度
				trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;

				///<开始离心/向心扫描(横向由于间隔固定所以一般不会出现偏离的情况，除非料盘本身严重变形或者中心定位出问题)

				calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);

				//模板匹配/更新元件精确位置
				double maxyyu;
				//findTrackModel(srcPrev, tplMat, 90.0 - (trackAngle + 180.0), trackWidth, pts, (255 - backT), false, maxyyu, trackCenter, cv::noArray());

				//进一步确认元件位置
				bool trayEnd = false;
				if (true) {
					//考虑增加[-2,2]角度范围以应对料盘变形
					trayEnd = findTrackModel(srcPrev, tplMat, 90.0 - (trackAngle + 180.0), trackWidth, pts, (255 - backT), true, maxyyu, trackCenter, binary);
				}

				//if (cvRound(trackCenter.x) == 336 && cvRound(trackCenter.y) == 536)
				//	std::cout << "" << std::endl;

				//更新扫描半径
				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;

				//计算实际元件区域
				calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);

#ifdef _DEBUG
				cv::Point2f ptsT[4];
				calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, ptsT);

				if (!trayEnd)
				{
					//画出元件区域
					for (int j = 0; j < 4; j++)
					{
						cv::line(cc, ptsT[j], ptsT[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
					}
				}

#endif

				//判断是否追踪终止(增加匹配分数小于0.18被判定不是元件)
				if (trayEnd) {
					//不再判断，大概率已经终止
					found = false;
				}
				else if (trackMat.ptr<uint8_t>(cvRound(trackCenterT.y))[cvRound(trackCenterT.x)] == 255) {
					//不再判断，大概率已经终止
					found = false;
				}
				else if (trackMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] == 255) {

					//判断可能并未终止，遂采用理论位置作为下一个元件位置
					trackCenter = trackCenterT;

					//<更新追踪信息
					//更新扫描半径
					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;

					//计算理论元件区域
					calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);

					//标记为已追踪过
					std::vector<cv::Point> ptPoly = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
					cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));

					//标记计数
					lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;

					//标记当前位置
					cv::drawMarker(cc, trackCenter, cv::Scalar(0, 255, 0, 255), cv::MARKER_DIAMOND, 5);
					//cv::drawMarker(cc, trackCenter, cv::Scalar(0, 0, 255, 255), 0, 5);
				}
				else
				{
					//标记为已追踪过
					std::vector<cv::Point> ptPoly = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
					cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));

					//标记计数
					lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;

					//标记当前位置
					cv::drawMarker(cc, trackCenter, cv::Scalar(0, 255, 0, 255), cv::MARKER_DIAMOND, 5);
					//cv::drawMarker(cc, trackCenter, cv::Scalar(0, 0, 255, 255), 0, 5);
				}

				//跳过执行
				if (killProcessID == 0) {
					logger.t("eyemCountObjectIrregularPartsE 追踪阶段被跳过执行...");
					found = false;
				}
				//std::cout << "总体耗时：" << 1000 * (static_cast<double>(cv::getTickCount()) - begin0) / cv::getTickFrequency() << std::endl;

				trackEnd = (!found);
			} while (!trackEnd);

		}
#if OPTIMIZE_ON
			,
			[&]
#endif
		{
			//< 逆时针追踪
			//追踪起点
			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];
			//开始追踪
			bool trackEnd = true;
			//
			do
			{
				bool found = true;
				std::vector<Track> vParts;
				for (double t = trackAngle - (trackOffset / 3.0 + partDist + trackOffset / 2.0); t > trackAngle - \
					(trackOffset / 3.0 + partDist + trackOffset / 2.0) - trackOffset / 3.0; t -= dMinorStep)
				{
					trackCenter.x = float(reelCenter.x + trackRadius*cos(t*c));
					trackCenter.y = float(reelCenter.y + trackRadius*sin(t*c));

					//计算旋转矩形
					calcRotateRect(trackCenter, (float)t, (float)trackLength, (float)trackWidth, pts);

					//模板匹配
					double maxyyu; cv::Point2f maxyyuloc;
					findTrackModel(srcPrev, tplMat, 90.0 - (t + 180.0), trackWidth, pts, (255 - backT), false, maxyyu, maxyyuloc, cv::noArray());

					//最小匹配结果
					if (maxyyu > 0.15) {
						//存放结果
						vParts.push_back(Track(0, 0, maxyyu, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), std::vector<cv::Point2f>()));
					}

					//测试标记
					//cv::drawMarker(cc, cv::Point(cvRound(trackCenter.x), cvRound(trackCenter.y)), cv::Scalar(0, 165, 255, 255), 0, 5);
				}
				if (vParts.size() == 0)
					break;

				//更新切线方向位置,由于这个方向是元件间隙不会有太大偏差
				trackCenter = cv::Point2f((float)vParts[vParts.size() / 2].Pos.x, (float)vParts[vParts.size() / 2].Pos.y);

				//理论元件区域
				cv::Point2f trackCenterT(trackCenter.x, trackCenter.y);

				//更新扫描角度
				trackAngle = atan2((double)trackCenter.y - reelCenter.y, (double)trackCenter.x - reelCenter.x) * 180 / PI;

				///<开始离心/向心扫描(横向由于间隔固定所以一般不会出现偏离的情况，除非料盘本身严重变形或者中心定位出问题)

				calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);

				//模板匹配/更新元件精确位置+判断
				double maxyyu;
				//findTrackModel(srcPrev, tplMat, 90.0 - (trackAngle + 180.0), trackWidth, pts, (255 - backT), false, maxyyu, trackCenter, cv::noArray());

				//
				bool trayEnd = false;
				if (true) {
					//考虑增加[-2,2]角度范围以应对料盘变形
					trayEnd = findTrackModel(srcPrev, tplMat, 90.0 - (trackAngle + 180.0), trackWidth, pts, (255 - backT), true, maxyyu, trackCenter, binary);
				}

				//if (cvRound(trackCenter.x) == 1356 && cvRound(trackCenter.y) == 1812){
				//	std::cout << "xx" << std::endl;
				//}

				//更新扫描半径
				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;

				//计算实际元件位置
				calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);

#ifdef _DEBUG
				cv::Point2f ptsT[4];
				calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, ptsT);

				if (!trayEnd)
				{
					//画出元件区域
					for (int j = 0; j < 4; j++)
					{
						cv::line(cc, ptsT[j], ptsT[(j + 1) % 4], cv::Scalar(0, 0, 255, 255), 1);
					}
				}

#endif

				//判断是否追踪终止(增加匹配分数小于0.18被判定不是元件)
				if (trayEnd) {
					//不再判断，大概率已经终止
					found = false;
				}
				else if (trackMat.ptr<uint8_t>(cvRound(trackCenterT.y))[cvRound(trackCenterT.x)] == 255) {
					//不再判断，大概率已经终止
					found = false;
				}
				else if (trackMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] == 255) {

					//判断可能并未终止，遂采用理论位置作为下一个元件位置
					trackCenter = trackCenterT;

					///<更新追踪信息
					//更新扫描半径
					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;

					//计算理论元件位置
					calcRotateRect(trackCenter, (float)trackAngle, (float)trackLength, (float)trackWidth, pts);

					//标记为已追踪过
					std::vector<cv::Point> ptPoly = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
					cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));

					//标记计数
					lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;

					//标记当前位置
					cv::drawMarker(cc, trackCenter, cv::Scalar(0, 255, 0, 255), cv::MARKER_DIAMOND, 5);
					//cv::drawMarker(cc, trackCenter, cv::Scalar(0, 0, 255, 255), 0, 5);
				}
				else
				{
					//标记为已追踪过
					std::vector<cv::Point> ptPoly = { cv::Point(pts[0]),cv::Point(pts[1]) ,cv::Point(pts[2]) ,cv::Point(pts[3]) };
					cv::fillConvexPoly(trackMat, ptPoly, cv::Scalar(255));

					//标记计数
					lbMat.ptr<uint8_t>(cvRound(trackCenter.y))[cvRound(trackCenter.x)] = 255;

					//标记当前位置
					cv::drawMarker(cc, trackCenter, cv::Scalar(0, 255, 0, 255), cv::MARKER_DIAMOND, 5);
					//cv::drawMarker(cc, trackCenter, cv::Scalar(0, 0, 255, 255), 0, 5);
				}

				//跳过执行
				if (killProcessID == 0) {
					logger.t("eyemCountObjectIrregularPartsE 追踪阶段被跳过执行...");
					found = false;
				}

				trackEnd = (!found);
			} while (!trackEnd);
		}
#if OPTIMIZE_ON
		);
#endif
	}

	//计数
	int reelNum = cv::countNonZero(lbMat);

	//画图显示
	std::string text = "Reel Number = " + std::to_string(reelNum);
	cv::putText(cc, text, cv::Point(35, 35), 0, 1.0, cv::Scalar(0, 140, 255, 255), 2);

	//<输出结果
	const int SizeConst = 4;
	//<输出计数结果标记图像
	{
		memset(ipReelNum, 0, SizeConst);

		ipReelNum[0] = reelNum;

		tpDstImg->iWidth = cc.cols; tpDstImg->iHeight = cc.rows; tpDstImg->iDepth = cc.depth(); tpDstImg->iChannels = cc.channels();

		//内存尺寸
		int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);

		//分配初始化内存
		tpDstImg->vpImage = (uint8_t *)malloc(_Size);
		if (NULL == tpDstImg->vpImage)
			return FUNC_NOT_ENOUGH_MEM;
		memset(tpDstImg->vpImage, 0, _Size);

		//拷贝数据
		memcpy(tpDstImg->vpImage, cc.data, _Size);
	}

	return FUNC_OK;
}

int eyemAchvMatchMat(EyemImage tpImage, EyemRect tpRoi, EyemImage *tpDstImg)
{
	cv::Mat src = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();
	if (src.empty()) {
		return FUNC_IMAGE_NOT_EXIST;
	}
	//转单通道
	if (src.channels() != 1)
		cv::cvtColor(src, src, cv::COLOR_BGR2GRAY);

	//跳过执行
	if (killProcessID == 0) {
		logger.t("eyemCountObjectIrregularPartsE 初始阶段被跳过执行...");
		return FUNC_CANNOT_CALC;
	}
	//图像裁剪
	src = src(cv::Rect(tpRoi.iXs, tpRoi.iYs, tpRoi.iWidth, tpRoi.iHeight)).clone();
	//image size
	int X = src.cols, Y = src.rows;
	//去除局部量斑影响（默认亮斑尺寸不会大于15个像素）
	cv::Mat srcTmp;
	cv::morphologyEx(src, srcTmp, cv::MORPH_ERODE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(15, 15)));

	//去除黑斑影响
	int m = cvRound(cv::mean(src)[0]);
	srcTmp.forEach<uint16_t>([&](uint16_t& pixel, const int *pos)->void {
		pixel = pixel == 0 ? m : pixel;
	});

	//图像增强
	double min, max;
	cv::Point maxId;
	cv::minMaxLoc(srcTmp, &min, &max, NULL, &maxId);
	src.convertTo(src, CV_64FC1);

	src -= min;
	src /= (max - min);
	src *= 65535;
	src.convertTo(src, CV_16UC1);

	cv::Mat src8U;
	src.convertTo(src8U, CV_8UC1, 1 / 255.);
	//显示结果图像
	cv::Mat cc;
	cv::cvtColor(src8U, cc, cv::COLOR_GRAY2BGRA);
	//设置bins
	const int histSize = 17;
	//range of values
	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 * cvRound(((double)maxIdx[0] - 2));//正常-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.ptr<uint8_t>(y)[x] >= backThresh) {
					src8U.ptr<uint8_t>(y)[x] = backThresh;
				}
			}
		}
	});
	//方便显示
	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);
	//连接在一起
	cv::morphologyEx(binary, binary, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, 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; std::vector<cv::Mat> matchMats;
	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));
		//获取局部图像
		cv::Rect bbox = cv::boundingRect(contoursFilter[i]);

		cv::Point pt(bbox.tl().x + bbox.width / 2, bbox.tl().y);

		cv::Rect limit(cv::Point2i(pt.x - 112, pt.y), cv::Point2i(pt.x + 112, pt.y + 224));

		matchMats.push_back(cc(limit).clone());
	}
	if (matchMats.empty()) {
		return FUNC_CANNOT_CALC;
	}

	cv::Mat matchMat;
	cv::cvtColor(matchMats[0], matchMat, cv::COLOR_BGRA2BGR);

	//<输出结果图像
	tpDstImg->iWidth = matchMat.cols; tpDstImg->iHeight = matchMat.rows; tpDstImg->iDepth = matchMat.depth(); tpDstImg->iChannels = matchMat.channels();
	//内存尺寸
	int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);
	//分配初始化内存
	tpDstImg->vpImage = (uint8_t *)malloc(_Size);
	if (NULL == tpDstImg->vpImage)
		return FUNC_NOT_ENOUGH_MEM;
	memset(tpDstImg->vpImage, 0, _Size);
	//拷贝数据
	memcpy(tpDstImg->vpImage, matchMat.data, _Size);
	return FUNC_OK;
}

int eyemAchvTemplateImage(EyemImage tpImage, EyemRect tpRoi, EyemImage *tpDstImg)
{
	cv::Mat image = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();

	//检查文件是否存在
	if (image.empty())
		return FUNC_IMAGE_NOT_EXIST;

	//转单通道图像
	if (image.channels() != 1)
		cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);

	//范围
	image = image(cv::Rect(tpRoi.iXs, tpRoi.iYs, tpRoi.iWidth, tpRoi.iHeight));

	//图像尺寸
	int X = image.cols, Y = image.rows;

	//去除局部量斑影响（默认亮斑尺寸不会大于15个像素）
	cv::Mat srcTmp;
	cv::morphologyEx(image, srcTmp, cv::MORPH_ERODE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(15, 15)));

	//去除局部黑斑影响
	int m = cvRound(cv::mean(image)[0]);
	srcTmp.forEach<uint16_t>([&](uint16_t& pixel, const int *pos)->void {
		pixel = pixel == 0 ? m : pixel;
	});

	//图像增强
	double min, max;
	cv::minMaxLoc(srcTmp, &min, &max);
	image.convertTo(image, CV_64FC1);

	image -= min;
	image /= (max - min);
	image *= 65535;
	image.convertTo(image, CV_16UC1);

	//转8位灰度图
	cv::Mat srcPrev;
	image.convertTo(srcPrev, CV_8UC1, 1 / 255.);

	//设定bin数目
	const int histSize = 17;
	//设定取值范围
	float range[] = { 0,255 };
	const float* histRange = { range };
	//计算直方图
	cv::Mat hist;
	cv::calcHist(&srcPrev, 1, 0, cv::Mat(), hist, 1, &histSize, &histRange);
	//计算背景像素
	int maxIdx[2] = { 255,255 };
	cv::minMaxIdx(hist, NULL, NULL, NULL, maxIdx);
	//背景阈值
	int backT = 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 (srcPrev.ptr<uint8_t>(y)[x] >= backT)
				{
					srcPrev.ptr<uint8_t>(y)[x] = backT;
				}
			}
		}
	});

	///<输出计数结果标记图像
	{
		tpDstImg->iWidth = srcPrev.cols; tpDstImg->iHeight = srcPrev.rows; tpDstImg->iDepth = srcPrev.depth(); tpDstImg->iChannels = srcPrev.channels();

		//内存尺寸
		int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);

		//分配初始化内存
		tpDstImg->vpImage = (uint8_t *)malloc(_Size);
		if (NULL == tpDstImg->vpImage)
			return FUNC_NOT_ENOUGH_MEM;
		memset(tpDstImg->vpImage, 0, _Size);

		//拷贝数据
		memcpy(tpDstImg->vpImage, srcPrev.data, _Size);
	}

	return FUNC_OK;
}

int eyemCreateTemplateModel(EyemImage tpImage, EyemRect tpRoi, double dMinScore, const char *ccTplName)
{
	cv::Mat image = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();

	if (image.empty())
		return FUNC_IMAGE_NOT_EXIST;

	cv::Mat tplMat = image(cv::Rect(tpRoi.iXs, tpRoi.iYs, tpRoi.iWidth, tpRoi.iHeight)).clone();

	//反转
	cv::bitwise_not(tplMat, tplMat);

	//内存尺寸(将信息添加到图像后面)
	int _Size = tplMat.cols*tplMat.rows*tplMat.channels() * sizeof(uint8_t);

	//模板信息
	std::string hint = std::to_string(tpRoi.iXs) + "," + std::to_string(tpRoi.iYs) + "," \
		+ std::to_string(tpRoi.iWidth) + "," + std::to_string(tpRoi.iHeight) + "," + std::to_string(dMinScore);

	std::string szSize = std::to_string(_Size);

	std::string head = std::string(8 - szSize.length(), '0') + szSize;

	unsigned char *_Data = new unsigned char[_Size + hint.size() + 8];

	if (NULL == _Data)
		return FUNC_NOT_ENOUGH_MEM;

	//拷贝头数据
	memcpy(_Data, head.c_str(), 8);

	//拷贝图像数据
	memcpy(_Data + 8, tplMat.data, _Size);

	//拷贝图像信息数据
	memcpy(_Data + _Size + 8, hint.c_str(), hint.size());

	//写入本地
	std::ofstream ostream(ccTplName, std::ios::binary);
	ostream.write(reinterpret_cast<const char *>(_Data), _Size + hint.size() + 8);

	//释放资源
	delete[] _Data;
	_Data = NULL;

	//关闭流
	ostream.close();

	return FUNC_OK;
}

int eyemInitModel(const char *ccTplName, IntPtr *hModelID)
{
	std::string logModule = "";
	logModule += __func__;

	logModule += "(" + std::to_string(*(uint32_t *)(&std::this_thread::get_id())) + "):";

	logger.t(logModule + "初始化模板...");
	//获取文件路径
	std::vector<std::string> fileNames;
	cv::glob(ccTplName, fileNames);

	logger.t(logModule + "获取文件名...");
	//载入所有模板
	std::vector<EyemModelID> *tpModelID = new std::vector<EyemModelID>();

	//判断文件
	if (fileNames.size() <= 0) {
		//输出
		*hModelID = reinterpret_cast<IntPtr>(tpModelID);
		return FUNC_OK;
	}

	for (std::vector<std::string>::iterator it = fileNames.begin(); it != fileNames.end(); ++it)
	{
		std::string fileName = (*it);

		cv::Mat tplMat;	double matchDeg;
		try
		{
			logger.t(logModule + "开始从本地加载模板文件...");
			loadTrackModel(fileName.c_str(), tplMat, cv::Point(), matchDeg, "eyemInitModel");
		}
		catch (...) {
			logger.t(logModule + "从本地加载模板文件异常...");
			return FUNC_CANNOT_CALC;
		}

		if (!tplMat.empty()) {

			cv::Mat _tplMat;
			cv::bitwise_not(tplMat, _tplMat);

			//载入模板
			EyemModelID modelID;

			int _Size = tplMat.cols*tplMat.rows * sizeof(unsigned char);

			//数据
			logger.t(logModule + "分配模板图像内存...");
			modelID.vpImage = (unsigned char *)malloc(_Size);

			if (NULL == modelID.vpImage)
				return FUNC_NOT_ENOUGH_MEM;

			//拷贝数据
			logger.t(logModule + "拷贝模板数据...");
			memcpy(modelID.vpImage, _tplMat.data, _Size);

			//位置
			modelID.iXs = modelID.iYs = 0;

			//宽、高
			modelID.iWidth = tplMat.cols; modelID.iHeight = tplMat.rows;

			//匹配分数
			modelID.dMatchDeg = matchDeg;

			//名称?会导致内存泄露吗
			logger.t(logModule + "分配模板文件名内存...");
			modelID.lpszName = (char *)CoTaskMemAlloc(128);
			if (NULL != modelID.lpszName)
			{
				char file[128] = { 0 };
				sprintf_s(file, "%s", fileName.c_str());
				strcpy(modelID.lpszName, file);
			}
			else return FUNC_NOT_ENOUGH_MEM;

			//压入容器末尾
			logger.t(logModule + "将模板压入容器...");
			tpModelID->push_back(modelID);
		}
	}
	//输出
	*hModelID = reinterpret_cast<IntPtr>(tpModelID);

	return FUNC_OK;
}

int eyemAchvModelByName(const char *ccTplName, IntPtr hModelID, EyemModelID &tpModelID)
{
	if (NULL == hModelID)
		return FUNC_CANNOT_CALC;

	std::vector<EyemModelID> *tpModelIDs = reinterpret_cast<std::vector<EyemModelID>*>(hModelID);

	for (std::vector<EyemModelID>::iterator it = tpModelIDs->begin(); it != tpModelIDs->end(); ++it) {
		if (std::strcmp((*it).lpszName, ccTplName) == 0) {
			EyemModelID modelID = (*it);

			tpModelID.dMatchDeg = modelID.dMatchDeg; tpModelID.iHeight = modelID.iHeight; tpModelID.iWidth = modelID.iWidth;
			tpModelID.iXs = tpModelID.iYs = 0;
			tpModelID.lpszName = modelID.lpszName;
			tpModelID.vpImage = modelID.vpImage;
			break;
		}
	}

	return FUNC_OK;
}

int eyemInsertModel(IntPtr hModelID, const char *ccTplName)
{
	std::string logModule = "";
	logModule += __func__;

	logModule += "(" + std::to_string(*(uint32_t *)(&std::this_thread::get_id())) + "):";

	if (NULL == hModelID)
		return FUNC_CANNOT_CALC;


	logger.t(logModule + "从指针获取模板对象...");
	std::vector<EyemModelID> *tpModelID = reinterpret_cast<std::vector<EyemModelID>*>(hModelID);

	//判断是否重复
	for (std::vector<EyemModelID>::iterator it = tpModelID->begin(); it != tpModelID->end(); ++it) {

		if (std::strcmp((*it).lpszName, ccTplName) == 0) {
			return FUNC_OK;
		}
	}

	//加载指定模板
	cv::Mat tplMat;	double matchDeg;

	try
	{
		logger.t(logModule + "开始从本地加载模板文件...");
		loadTrackModel(ccTplName, tplMat, cv::Point(), matchDeg, "eyemInsertModel");
	}
	catch (...) {
		logger.t(logModule + "从本地加载模板文件异常...");
		return FUNC_CANNOT_CALC;
	}

	//插到容器末尾
	if (!tplMat.empty()) {

		cv::Mat _tplMat;
		cv::bitwise_not(tplMat, _tplMat);

		//载入模板
		EyemModelID modelID;

		int _Size = tplMat.cols*tplMat.rows * sizeof(unsigned char);

		//数据
		logger.t(logModule + "分配图像内存...");
		modelID.vpImage = (unsigned char *)malloc(_Size);

		if (NULL == modelID.vpImage)
			return FUNC_NOT_ENOUGH_MEM;

		//拷贝数据
		logger.t(logModule + "拷贝图像数据...");
		memcpy(modelID.vpImage, _tplMat.data, _Size);

		//位置
		modelID.iXs = modelID.iYs = 0;

		//宽、高
		modelID.iWidth = tplMat.cols; modelID.iHeight = tplMat.rows;

		//匹配分数
		modelID.dMatchDeg = matchDeg;

		//名称
		logger.t(logModule + "分配模板文件名内存...");
		modelID.lpszName = (char *)CoTaskMemAlloc(128);
		if (NULL != modelID.lpszName)
		{
			char file[128] = { 0 };
			sprintf_s(file, "%s", ccTplName);
			strcpy(modelID.lpszName, file);
		}
		else {
			return FUNC_NOT_ENOUGH_MEM;
		}

		//压入容器末尾
		logger.t(logModule + "将模板压入容器...");
		tpModelID->push_back(modelID);
	}
	else {
		return FUNC_CANNOT_CALC;
	}

	return FUNC_OK;
}

int eyemRemoveModelByName(IntPtr hModelID, const char *ccTplName)
{
	if (NULL == hModelID)
		return FUNC_CANNOT_CALC;

	std::vector<EyemModelID> *tpModelID = reinterpret_cast<std::vector<EyemModelID>*>(hModelID);

	//遍历移除
	for (std::vector<EyemModelID>::iterator it = tpModelID->begin(); it != tpModelID->end(); ++it) {

		EyemModelID *modelID = &(*it);
		if (std::strcmp((const char *)modelID->lpszName, ccTplName) == 0) {
			//释放资源
			modelID->dMatchDeg = modelID->iHeight = modelID->iWidth = modelID->iXs = modelID->iYs = 0;

			//释放内容
			CoTaskMemFree((LPVOID)modelID->lpszName);
			free(modelID->vpImage);
			//
			modelID->vpImage = NULL; modelID->lpszName = NULL;
			//删除
			tpModelID->erase(it);
			break;
		}
	}

	return FUNC_OK;
}

int eyemRemoveModelByID(IntPtr hModelID, const int iTplID)
{

	return FUNC_OK;
}

int eyemMatchTemplateModel(EyemImage tpImage, IntPtr hModelID, char **lpszTplName)
{
	cv::Mat image = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();

	//判断图像是否存在
	if (image.empty() || NULL == hModelID)
		return FUNC_IMAGE_NOT_EXIST;

	//反转
	cv::bitwise_not(image, image);

	struct Track {
		double dMatchDeg;
		std::string tplName;
		cv::Mat tplMat;

		Track() {};

		Track(double dMatchDeg, std::string tplName, cv::Mat tplMat) :dMatchDeg(dMatchDeg), tplName(tplName), tplMat(tplMat) {};

		bool operator >(const Track &te)const
		{
			return dMatchDeg > te.dMatchDeg;
		}
	};
	//模板文件
	std::vector<EyemModelID>  *tpModelIDs = reinterpret_cast<std::vector<EyemModelID>*>(hModelID);

	//载入所有模板
	std::vector<Track> tplMats;
	for (std::vector<EyemModelID>::iterator it = tpModelIDs->begin(); it != tpModelIDs->end(); ++it)
	{
		EyemModelID tpModelID = (*it);

		cv::Mat tplMat;
		tplMat = cv::Mat(tpModelID.iHeight, tpModelID.iWidth, CV_8UC1, tpModelID.vpImage);

		//模板取反
		cv::Mat _tplMat;
		cv::bitwise_not(tplMat, _tplMat);

		if (!tplMat.empty())
			tplMats.push_back(Track(tpModelID.dMatchDeg, tpModelID.lpszName, _tplMat));
	}

	//模板文件不存在
	if (tplMats.size() <= 0)
		return FUNC_CANNOT_CALC;

	const float icvDirections[4] = { 0 , 90 , 180 , -90 };

	//遍历所有模板选择最佳匹配模板
	cv::parallel_for_(cv::Range(0, (int)tplMats.size()), [&](const cv::Range& range)->void {
		for (int tpl = range.start; tpl < range.end; tpl++)
		{
			double sumMatchDeg = 0.0; int sumMatchNum = 0;

			//模板匹配(仅处理料盘区域以提高速度)
			cv::Mat tplMat = tplMats[tpl].tplMat;

			cv::Mat tplResult;
			cv::matchTemplate(image, getTplMat(tplMats[tpl].tplMat, icvDirections[0], 0), tplResult, cv::TM_CCOEFF_NORMED);

			//分数大于一定分数才当作元件处理
			cv::Mat tplResult0 = cv::Mat(tplResult > tplMats[tpl].dMatchDeg);

			//连通域分析
			cv::Mat labels, stats, centroids;
			int nccomps = cv::connectedComponentsWithStats(tplResult0, labels, stats, centroids);

			if (nccomps > 1) {
				//累加分数
				double maxVal = 0.;
				for (int i = 1; i < nccomps; i++) {
					sumMatchNum++;
					cv::minMaxLoc(tplResult(cv::Rect(stats.ptr<int>(i)[cv::CC_STAT_LEFT], stats.ptr<int>(i)[cv::CC_STAT_TOP], \
						stats.ptr<int>(i)[cv::CC_STAT_WIDTH], stats.ptr<int>(i)[cv::CC_STAT_HEIGHT])), NULL, &maxVal, NULL, NULL);
					sumMatchDeg += maxVal;
				}
			}
			if (sumMatchNum != 0) {
				tplMats[tpl].dMatchDeg = sumMatchDeg / (double)sumMatchNum;
			}
			else {
				tplMats[tpl].dMatchDeg = 0.0;
			}
		}
	});

	//计算最佳匹配模板
	std::sort(tplMats.begin(), tplMats.end(), std::greater<Track>());

	//最匹配模板
	std::string bestMatch = "";

	int select = 0;
	do
	{
		bestMatch += tplMats[select].tplName + ",";
		select++;
	} while (select < 5 && select < tplMats.size());

	//输出结果
	*lpszTplName = (char *)CoTaskMemAlloc(bestMatch.length() + 1);
	if (NULL != lpszTplName)
	{
		strcpy(*lpszTplName, bestMatch.c_str());
	}
	else {
		return FUNC_NOT_ENOUGH_MEM;
	}

	return FUNC_OK;
}

int eyemReleaseModel(IntPtr &hModelID)
{
	if (NULL == hModelID)
		return FUNC_OK;

	std::vector<EyemModelID>  *tpModelID = reinterpret_cast<std::vector<EyemModelID>*>(hModelID);

	for (std::vector<EyemModelID>::iterator it = tpModelID->begin(); it != tpModelID->end(); ++it) {

		EyemModelID *modelID = &(*it);

		modelID->dMatchDeg = modelID->iHeight = modelID->iWidth = modelID->iXs = modelID->iYs = 0;

		//释放内容
		CoTaskMemFree((LPVOID)modelID->lpszName);
		free(modelID->vpImage);
	}
	//清空容器
	tpModelID->clear();

	//释放容器
	delete tpModelID;
	tpModelID = NULL; hModelID = NULL;

	return FUNC_OK;
}

int eyemTrackFeature(EyemImage tpRefImg, EyemImage tpNextImg, EyemRect3 *tpRois, int iRoiNum, int *ipResults, EyemImage *tpDstImg)
{
	cv::Mat refImg = cv::Mat(tpRefImg.iHeight, tpRefImg.iWidth, MAKETYPE(tpRefImg.iDepth, tpRefImg.iChannels), tpRefImg.vpImage).clone();

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

	if (refImg.empty() | nextImg.empty())
		return FUNC_IMAGE_NOT_EXIST;

	//显示图像
	cv::Mat showMat;
	showMat = nextImg.clone();

	//转灰度图像
	if (refImg.channels() != 1) {
		cv::cvtColor(refImg, refImg, cv::COLOR_BGR2GRAY);
	}

	if (nextImg.channels() != 1) {
		cv::cvtColor(nextImg, nextImg, cv::COLOR_BGR2GRAY);
	}

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

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

	for (int i = 0; i < iRoiNum; i++)
	{
		cv::Mat labels, stats, centroids;
		int nccomps = cv::connectedComponentsWithStats(binary(cv::Rect(tpRois[i].iXs, tpRois[i].iYs, tpRois[i].iWidth, tpRois[i].iHeight)), \
			labels, stats, centroids);
		//判断结果
		if (((double)cv::countNonZero(labels) / (double(tpRois[i].iWidth*(double)tpRois[i].iHeight))) > tpRois[i].dVar)
		{
			ipResults[i] = 1;
		}
		else
			ipResults[i] = 0;

		//寻找轮廓
		std::vector<std::vector<cv::Point>> contours;
		cv::findContours(binary(cv::Rect(tpRois[i].iXs, tpRois[i].iYs, tpRois[i].iWidth, tpRois[i].iHeight)), contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);

		//画图
		for (int j = 0; j < contours.size(); j++)
		{
			cv::drawContours(showMat, contours, j, cv::Scalar(0, 0, 255), 3, 8, cv::noArray(), 2147483647, cv::Point(tpRois[i].iXs, tpRois[i].iYs));
		}
	}
	//<输出结果图像
	{
		tpDstImg->iWidth = showMat.cols; tpDstImg->iHeight = showMat.rows; tpDstImg->iDepth = showMat.depth(); tpDstImg->iChannels = showMat.channels();

		//内存尺寸
		int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);

		//分配初始化内存
		tpDstImg->vpImage = (uint8_t *)malloc(_Size);
		if (NULL == tpDstImg->vpImage)
			return FUNC_NOT_ENOUGH_MEM;
		memset(tpDstImg->vpImage, 0, _Size);

		//拷贝数据
		memcpy(tpDstImg->vpImage, showMat.data, _Size);
	}
	return FUNC_OK;
}

int eyemAOIForTSAV(EyemImage tpRefImg, EyemImage tpNextImg, EyemRect3 *tpRois, int iRoiNum)
{
	return FUNC_OK;
}

int eyemMarkerTracing(EyemImage tpImage, EyemHSVModel tpHSVModel, EyemOcsFXYR *tpCircle, EyemImage *tpDstImg, bool bHighAccuracy)
{
	cv::Mat image = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();

	if (image.empty())
		return FUNC_IMAGE_NOT_EXIST;

	const int X = image.cols; const int Y = image.rows;
	int incn = image.channels();
	if (incn > 3) {
		cv::cvtColor(image, image, cv::COLOR_BGRA2BGR);
	}
	else if (incn == 1) {
		cv::cvtColor(image, image, cv::COLOR_GRAY2BGR);
	}
	//滤波
	cv::blur(image, image, cv::Size(5, 5));
	//用于显示
	cv::Mat cc = image.clone();

	//转hsv空间
	cv::Mat imgGray;
	cv::cvtColor(image, imgGray, cv::COLOR_BGR2HSV);
	//红色比较特殊，分两个区间
	cv::Mat mask1, mask2(cv::Size(X, Y), CV_8UC1, cv::Scalar(0));
	cv::inRange(imgGray, cv::Scalar(tpHSVModel.dpRangeL[0], tpHSVModel.dpRangeL[1], tpHSVModel.dpRangeL[2]),
		cv::Scalar(tpHSVModel.dpRangeU[0], tpHSVModel.dpRangeU[1], tpHSVModel.dpRangeU[2]), mask1);
	//多个分割阈值
	if ((tpHSVModel.dpRangeLExt[0] + tpHSVModel.dpRangeLExt[1] + tpHSVModel.dpRangeLExt[2]) != 0 ||
		(tpHSVModel.dpRangeUExt[0] + tpHSVModel.dpRangeUExt[1] + tpHSVModel.dpRangeUExt[2]) != 0) {
		cv::inRange(imgGray, cv::Scalar(tpHSVModel.dpRangeLExt[0], tpHSVModel.dpRangeLExt[1], tpHSVModel.dpRangeLExt[2]),
			cv::Scalar(tpHSVModel.dpRangeUExt[0], tpHSVModel.dpRangeUExt[1], tpHSVModel.dpRangeUExt[2]), mask2);
	}
	//合并
	cv::Mat maskj;
	cv::bitwise_or(mask1, mask2, maskj);

	//去掉干扰
	cv::morphologyEx(maskj, maskj, cv::MORPH_OPEN, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3)));

	//测试用，局部用RBG分割
	cv::Mat labels, stats, centroids;
	int nccomps = cv::connectedComponentsWithStats(maskj, labels, stats, centroids);
	//过滤连通域面积及长/宽比例不符合的,允许50%误差
	std::vector<uchar> colors(nccomps + 1, 0);
	for (int i = 1; i < nccomps; i++) {
		colors[i] = 255;
		double minSize = cv::min(stats.ptr<int>(i)[cv::CC_STAT_WIDTH], stats.ptr<int>(i)[cv::CC_STAT_HEIGHT]); double dRate = (double)stats.ptr<int>(i)[cv::CC_STAT_WIDTH] / (double)stats.ptr<int>(i)[cv::CC_STAT_HEIGHT];
		if (minSize < 24 || !(dRate > 0.75&&dRate < 1.25))
		{
			colors[i] = 0;
		}
	}
	//过滤
	cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
		for (int y = range.start; y < range.end; y++)
		{
			uint8_t *ptrRow = maskj.ptr<uint8_t>(y);
			for (int x = 0; x < X; x++)
			{
				int label = labels.ptr<int>(y)[x];
				CV_Assert(0 <= label && label <= nccomps);
				ptrRow[x] = colors[label];
			}
		}
	});
	//针对区域再进行过滤
	std::vector<std::vector<cv::Point>> contours, contourFilter;
	cv::findContours(maskj, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE);
	for (auto&contour : contours) {
		cv::Rect bbox = cv::boundingRect(contour);
		int minSize = cv::min(bbox.height, bbox.width);
		cv::Rect limRec = cv::Rect(cv::Point2i(bbox.tl().x - minSize, bbox.tl().y - minSize),
			cv::Point2i(bbox.br().x + minSize, bbox.br().y + minSize))&cv::Rect(0, 0, X, Y);

		cv::Mat limit = image(limRec).clone();
		//过滤
		std::vector<cv::Point> approx;
		float arcL = (float)cv::arcLength(cv::Mat(contour), true);
		cv::approxPolyDP(cv::Mat(contour), approx, arcL*0.01, true);
		if (approx.size() > 5) {
			cv::Rect bbox = cv::boundingRect(contour);
			if (MIN(bbox.width, bbox.height) > 24 && ((float)bbox.width / (float)bbox.height) > 0.75 && \
				((float)bbox.width / (float)bbox.height) < 1.25) {
				//圆度
				double afa = 4.0f*CV_PI*cv::contourArea(contour, false) / std::pow(arcL, 2);
				if (afa > 0.45) {
					contourFilter.push_back(contour);
				}
			}
		}
	}

	struct AFA {
		double dMatchDeg;
		EyemOcsDXYR tpCircle;
		AFA() {};

		AFA(double dMatchDeg, EyemOcsDXYR tpCircle) :dMatchDeg(dMatchDeg), tpCircle(tpCircle) {};

		bool operator >(const AFA &te)const
		{
			return dMatchDeg > te.dMatchDeg;
		}
		bool operator <(const AFA &te)const
		{
			return dMatchDeg < te.dMatchDeg;
		}
	};

	if (contourFilter.empty()) {
		return FUNC_FAILED_DETECT;
	}

	bool typeCircle = true;
	if (typeCircle) {
		std::vector<AFA> AFAs;
		//画图
		for (auto&contour : contourFilter) {
			std::vector<EyemOcsDXY> taPoints;
			for (int n = 0; n < contour.size(); n++) {
				EyemOcsDXY taPoint;
				taPoint.dX = (double)contour[n].x;
				taPoint.dY = (double)contour[n].y;
				taPoints.push_back(taPoint);
			}
			double min_err;
			EyemOcsDXYR _tpCircle;
			eyemFitCircle((int)taPoints.size(), &taPoints[0], 10, min_err, _tpCircle);
			AFAs.push_back(AFA(min_err, _tpCircle));
		}
		if (AFAs.empty()) {
			return FUNC_FAILED_DETECT;
		}
		//排序
		std::sort(AFAs.begin(), AFAs.end(), std::less<AFA>());
		//高精度定位
		if (false) {
			EyemOcsDXY tpPoint; IntPtr hObject;
			tpPoint.dX = AFAs[0].tpCircle.dX; tpPoint.dY = AFAs[0].tpCircle.dY;
			//提取图像
			std::vector<cv::Mat> mvx;
			cv::split(cc, mvx);
			EyemImage imageRed; imageRed.iWidth = cc.cols; imageRed.iHeight = cc.rows; imageRed.iDepth = cc.depth(); imageRed.iChannels = 1; imageRed.vpImage = mvx[2].data;
			int iRadius = 27, iCapLength = 9, iCapWidth = 6, nCalipers = 19, nFilterSize = 2, iSearchDirec = 1;
			eyemEdge1dFindCircle(imageRed, tpPoint, iRadius, iCapLength, iCapWidth, nCalipers, nFilterSize, iSearchDirec, 35, "positive", &hObject);
			//拟合
			std::vector<EyemOcsDXY> *tpResults = reinterpret_cast<std::vector<EyemOcsDXY>*>(hObject);
			double rms; EyemOcsDXYR _tpCircle;
			eyemFitCircle((int)tpResults->size(), tpResults->data(), 5, rms, _tpCircle);
			//输出
			tpCircle->fX = (float)_tpCircle.dX;
			tpCircle->fY = (float)_tpCircle.dY;
			tpCircle->fR = (float)_tpCircle.dR;
			//释放
			eyemEdge1dGenMeasureFree(hObject);
		}
		else {
			//输出
			tpCircle->fX = (float)AFAs[0].tpCircle.dX;
			tpCircle->fY = (float)AFAs[0].tpCircle.dY;
			tpCircle->fR = (float)AFAs[0].tpCircle.dR;
		}
		//画图
		cv::rectangle(cc, cv::Rect(cv::Point2f(tpCircle->fX - 2.0f*tpCircle->fR, tpCircle->fY - 2.0f*tpCircle->fR),
			cv::Point2f(tpCircle->fX + 2.0f*tpCircle->fR, tpCircle->fY + 2.0f*tpCircle->fR)), cv::Scalar(0, 255, 255), 4);
		cv::drawMarker(cc, cv::Point2f(tpCircle->fX, tpCircle->fY), cv::Scalar(0, 255, 0), cv::MARKER_CROSS, 20, 1);
	}
	else {
		std::vector<AFA> rboxes;
		//过滤
		std::vector<cv::Point> approx;
		for (auto&contour : contours) {
			float arcL = (float)cv::arcLength(cv::Mat(contour), true);
			cv::approxPolyDP(cv::Mat(contour), approx, arcL*0.01, true);
			if (approx.size() < 6) {
				cv::RotatedRect rbox = cv::minAreaRect(contour);
				if (std::max(rbox.size.width, rbox.size.height) > 20) {
					double min_err = (double)rbox.size.area() / cv::contourArea(contour);
					if (min_err > 0.85 && min_err < 1.15) {
						EyemOcsDXYR _tpCenter;
						_tpCenter.dR = std::min(rbox.size.width, rbox.size.height) / 2.0;
						_tpCenter.dX = rbox.center.x; _tpCenter.dY = rbox.center.y;
						rboxes.push_back(AFA(min_err, _tpCenter));
					}
				}
			}
		}
		if (rboxes.empty()) {
			return FUNC_FAILED_DETECT;
		}
		//排序
		std::sort(rboxes.begin(), rboxes.end(), std::less<AFA>());
		//输出
		tpCircle->fX = (float)rboxes[0].tpCircle.dX;
		tpCircle->fY = (float)rboxes[0].tpCircle.dY;
		tpCircle->fR = (float)rboxes[0].tpCircle.dR;
	}
	//<输出结果图像
	tpDstImg->iWidth = cc.cols; tpDstImg->iHeight = cc.rows; tpDstImg->iDepth = cc.depth(); tpDstImg->iChannels = cc.channels();
	//内存尺寸
	int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);
	//分配初始化内存
	tpDstImg->vpImage = (uint8_t *)malloc(_Size);
	if (NULL == tpDstImg->vpImage)
		return FUNC_NOT_ENOUGH_MEM;
	memset(tpDstImg->vpImage, 0, _Size);
	//拷贝数据
	memcpy(tpDstImg->vpImage, cc.data, _Size);
	return FUNC_OK;
}

int eyemMulFuncTool(EyemImage tpImage, EyemRect tpRoi, const char *funcName, double dThreshold, int iNumToIgnore, EyemOcsFXYR *tpCircle, EyemImage *tpDstImg)
{
	cv::Mat image = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone()(
		cv::Rect(tpRoi.iXs, tpRoi.iYs, tpRoi.iWidth, tpRoi.iHeight));

	if (image.empty())
		return FUNC_IMAGE_NOT_EXIST;

	const int X = image.cols; const int Y = image.rows;

	if (strcmp(funcName, "__func1") == 0) {
		int incn = image.channels();
		if (incn > 3) {
			cv::cvtColor(image, image, cv::COLOR_BGRA2GRAY);
		}
		else if (incn == 3) {
			cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);
		}
		else if (incn == 1) {
		}
		//高斯滤波
		cv::Mat imagePrev;
		cv::blur(image, imagePrev, cv::Size(15, 15));

		//二值化
		cv::Mat binary;
		if (dThreshold == 0.0) {
			cv::threshold(imagePrev, binary, dThreshold, 255, cv::THRESH_BINARY_INV | cv::THRESH_OTSU);
		}
		else {
			cv::threshold(imagePrev, binary, dThreshold, 255, cv::THRESH_BINARY_INV);
		}

		//去掉干扰
		cv::Mat mask;
		cv::morphologyEx(binary, mask, cv::MORPH_CLOSE, cv::getStructuringElement(cv::MORPH_RECT, cv::Size(45, 45)));

		//填充孔洞
		std::vector<std::vector<cv::Point>> contours;
		cv::findContours(mask, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);
		for (auto contourIdx = 0; contourIdx < contours.size(); contourIdx++) {
			cv::drawContours(mask, contours, contourIdx, cv::Scalar(255), -1);
		}
		//计算最大连通域
		cv::Mat labels, stats, centroids;
		int nccomps = cv::connectedComponentsWithStats(mask, labels, stats, centroids);

		double maxVal;
		cv::minMaxIdx(stats(cv::Range(1, stats.rows), cv::Range(4, 5)), NULL, &maxVal);

		//过滤连通域面积<=maxVal的
		std::vector<uchar> colors(nccomps + 1, 0);
		for (int i = 1; i < nccomps; i++) {
			colors[i] = 255;
			if ((stats.ptr<int>(i)[cv::CC_STAT_AREA] < maxVal))
			{
				colors[i] = 0;
			}
		}
		//过滤
		cv::parallel_for_(cv::Range(0, Y), [&](const cv::Range& range)->void {
			for (int y = range.start; y < range.end; y++)
			{
				uint8_t *ptrRow = mask.ptr<uint8_t>(y);
				for (int x = 0; x < X; x++)
				{
					int label = labels.ptr<int>(y)[x];
					CV_Assert(0 <= label && label <= nccomps);
					ptrRow[x] = colors[label];
				}
			}
		});

		//定位
		cv::findContours(mask, contours, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);

		std::vector<EyemOcsDXY> taPoints;
		for (auto&contour : contours) {
			for (int n = 0; n < contour.size(); n++) {
				EyemOcsDXY taPoint;
				taPoint.dX = (double)contour[n].x;
				taPoint.dY = (double)contour[n].y;
				taPoints.push_back(taPoint);
			}
		}

		double min_err;
		EyemOcsDXYR _tpCircle;
		eyemFitCircle((int)taPoints.size(), &taPoints[0], iNumToIgnore, min_err, _tpCircle);

		//画图
		cv::Mat showMat;
		cv::cvtColor(image, showMat, cv::COLOR_GRAY2RGB);
		cv::circle(showMat, cv::Point(cvRound(_tpCircle.dX), cvRound(_tpCircle.dY)), cvRound(_tpCircle.dR), cv::Scalar(0, 255, 0), 2);

		//输出
		tpCircle->fX = (float)_tpCircle.dX + (float)tpRoi.iXs;
		tpCircle->fY = (float)_tpCircle.dY + (float)tpRoi.iYs;
		tpCircle->fR = (float)_tpCircle.dR;

		//输出结果图像
		{
			if (NULL != tpDstImg->vpImage) {
				tpDstImg->iWidth = tpDstImg->iHeight = tpDstImg->iDepth = tpDstImg->iChannels = 0;
				//释放
				free(tpDstImg->vpImage);
				tpDstImg->vpImage = NULL;
			}

			tpDstImg->iWidth = mask.cols; tpDstImg->iHeight = mask.rows; tpDstImg->iDepth = mask.depth(); tpDstImg->iChannels = mask.channels();

			//内存尺寸
			int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);

			//分配初始化内存
			tpDstImg->vpImage = (uint8_t *)malloc(_Size);
			if (NULL == tpDstImg->vpImage)
				return FUNC_NOT_ENOUGH_MEM;
			memset(tpDstImg->vpImage, 0, _Size);

			//拷贝数据
			memcpy(tpDstImg->vpImage, mask.data, _Size);
		}
	}
	else if (strcmp(funcName, "__func2") == 0) {

	}
	else {
		//there is no function named for this
		return FUNC_CANNOT_USE;
	}
	return FUNC_OK;
}

#include "eyemMatchShapes.h"
int eyemLibImpl(EyemImage tpImage, EyemHSVModel tpHSVModel, EyemImage *tpDstImg)
{
	CV_Assert(NULL != tpImage.vpImage);

	cv::Mat image = cv::Mat(tpImage.iHeight, tpImage.iWidth, MAKETYPE(tpImage.iDepth, tpImage.iChannels), tpImage.vpImage).clone();

	if (image.empty())
		return FUNC_IMAGE_NOT_EXIST;

	//多个分割阈值
	if ((tpHSVModel.dpRangeLExt[0] + tpHSVModel.dpRangeLExt[1] + tpHSVModel.dpRangeLExt[2]) != 0 ||
		(tpHSVModel.dpRangeUExt[0] + tpHSVModel.dpRangeUExt[1] + tpHSVModel.dpRangeUExt[2]) != 0) {
		std::cout << "红色" << std::endl;
	}

	return FUNC_OK;

	//shape_based_matching GM;		// object to implent geometric matching	
	//int lowThreshold = 10;		//deafult value
	//int highThreashold = 100;		//deafult value

	//double minScore = 0.25;		//deafult value
	//double greediness = 0.8;		//deafult value

	//double total_time = 0;
	//double score = 0;

	//cv::Point result;

	//cv::Mat templateImage = cv::imread("D://批量测试图像//template2.png", cv::IMREAD_GRAYSCALE);
	//if (templateImage.data == NULL)
	//{
	//	return 0;
	//}

	////Load Search Image
	//cv::Mat searchImage = cv::imread("D://批量测试图像//rings_01.png", cv::IMREAD_GRAYSCALE);
	//if (searchImage.data == NULL)
	//{
	//	return 0;
	//}

	//lowThreshold = atoi("10");

	//highThreashold = atoi("100");//get high threshold

	//minScore = atof("0.25");

	//greediness = atof("0.9");

	//cv::Mat grayTemplateImg;  //(templateImage.size(), CV_8U, 1);

	//templateImage.copyTo(grayTemplateImg);


	//if (GM.create_shape_model(grayTemplateImg, lowThreshold, highThreashold) != FUNC_OK)
	//{
	//	std::cout << "ERROR: could not create model...";
	//	return 0;
	//}
	//else {
	//	cv::Mat cc;
	//	cv::cvtColor(templateImage, cc, cv::COLOR_GRAY2BGR);
	//}

	////测试用833
	////测试用
	//cv::Mat cc;
	//cv::cvtColor(templateImage, cc, cv::COLOR_GRAY2BGR);
	//for (int i = 0; i < 833; i++)
	//{

	//	//cc.ptr<cv::Vec3b>(resultPoints)[resultPoints[i].y] = cv::Vec3b(0, 0, 255);
	//}

	////CvSize searchSize = cvSize(searchImage->width, searchImage->height);
	//cv::Mat graySearchImg; //= cvCreateImage(searchSize, IPL_DEPTH_8U, 1);

	//				   // Convert color image to gray image. 
	//searchImage.copyTo(graySearchImg);

	//clock_t start_time1 = clock();
	//score = GM.find_shape_model(graySearchImg, minScore, greediness, &result);
	//clock_t finish_time1 = clock();
	//total_time = ((double)finish_time1 - (double)start_time1) / CLOCKS_PER_SEC;

	//cv::Mat rgb;
	//if (score > minScore) // if score is atleast 0.4
	//{
	//	std::cout << " Found at [" << result.x << ", " << result.y << "]\n Score = " << score << "\n Searching Time = " << total_time * 1000 << "ms";


	//	cvtColor(searchImage, rgb, cv::COLOR_GRAY2BGR);
	//	GM.draw_match_shapes(rgb, result, cv::Scalar(0, 255, 0), 1);
	//}
	//else
	//	std::cout << " Object Not found";
	////////////////////////////////////

	//std::cout << "\n ------------------------------------\n\n";
	//std::cout << "\n Press any key to exit!";

	////Display result
	//cv::Mat dispTemplate;
	//cvtColor(templateImage, dispTemplate, cv::COLOR_GRAY2BGR);
	//GM.draw_match_shapes(dispTemplate, CV_RGB(255, 0, 0), 1);
	//cv::namedWindow("Template", cv::WINDOW_AUTOSIZE);
	//cv::imshow("Template", dispTemplate);

	//cv::namedWindow("Search Image", cv::WINDOW_AUTOSIZE);
	//imshow("Search Image", rgb);

	//cv::waitKey(0);

	//cv::destroyWindow("Search Image");
	//cv::destroyWindow("Template");
	//return 0;


#pragma region resize img
	//const int minInputSize = 832;
	//float resizeRatio = (float)sqrt(image.cols * image.rows * 1.0 / (minInputSize * minInputSize));
	//int target_width = cvRound((float)image.cols / resizeRatio);
	//int target_height = cvRound((float)image.rows / resizeRatio);

	//cv::Mat input;
	//resize(image, input, cv::Size(image.cols / 2, image.rows / 2), 0, 0, cv::INTER_CUBIC);

	//image = input;
#pragma endregion


#pragma region wechat_qrcode

	//cv::Ptr<wechat_qrcode::WeChatQRCode> detector;

	//try {
	//	detector = cv::makePtr<wechat_qrcode::WeChatQRCode>(".\\opencv_3rdparty-wechat_qrcode\\detect.prototxt", ".\\opencv_3rdparty-wechat_qrcode\\detect.caffemodel",
	//		".\\opencv_3rdparty-wechat_qrcode\\sr.prototxt", ".\\opencv_3rdparty-wechat_qrcode\\sr.caffemodel");
	//}
	//catch (const std::exception& e) {
	//	std::cout << e.what() << std::endl;
	//	return 0;
	//}
	//std::string prevstr = "";
	//std::vector<cv::Mat> points;

	//auto res = detector->detectAndDecode(image, points);
	//for (const auto& t : res) std::cout << t << std::endl;

#pragma endregion


#pragma region darknet

	////加载类名
	//std::vector<std::string> classes;
	//std::string classFile = ".\\darknet\\detect.names";

	//std::ifstream ifs(classFile.c_str());

	//std::string line;
	//while (std::getline(ifs, line)) classes.push_back(line);

	////加载网络
	//cv::dnn::Net net = cv::dnn::readNet(".\\darknet\\yolov3-detect-tiny.cfg", ".\\darknet\\yolov3-detect-tiny_last.weights");
	//net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
	//net.setPreferableBackend(cv::dnn::DNN_TARGET_CPU);

	////获取输出层名称
	//auto layerNames = net.getLayerNames();

	//std::vector<int> outLayers = net.getUnconnectedOutLayers();

	//std::vector<std::string> outBlobNames(outLayers.size());
	//for (int i = 0; i < outLayers.size(); i++) {
	//	outBlobNames[i] = layerNames[outLayers[i] - 1];
	//}

	////预处理图像
	//cv::Mat blob;
	//cv::dnn::blobFromImage(image, blob, 1 / 255., cv::Size(608, 608));

	////为网络输入新值
	//net.setInput(blob);

	////获取预测结果
	//std::vector<cv::Mat> outputBlobs;
	//net.forward(outputBlobs, outBlobNames);

	//std::vector<int> classIds;//储存识别类的索引
	//std::vector<float> confidences;//储存置信度
	//std::vector<cv::Rect> bboxes;//储存边框

	//for (int n = 0; n < outputBlobs.size(); n++) {
	//	for (int row = 0; row < outputBlobs[n].rows; row++) {
	//		//置信度
	//		cv::Mat prob = outputBlobs[n](cv::Range(row, row + 1), cv::Range(5, outputBlobs[n].cols));

	//		double confidence;
	//		cv::Point classIdPoint;

	//		//取得最大分数值与索引
	//		cv::minMaxLoc(prob, 0, &confidence, 0, &classIdPoint);
	//		//如果置信度大于阈值
	//		if (confidence > 0.01) {

	//			cv::Mat dt = outputBlobs[n];

	//			cv::Mat x = outputBlobs[n](cv::Range(row, row + 1), cv::Range(0, 5));

	//			int cx = cvRound(x.ptr<float>(0)[0] * (float)image.cols);
	//			int cy = cvRound(x.ptr<float>(0)[1] * (float)image.rows);
	//			int w = cvRound(x.ptr<float>(0)[2] * (float)image.cols);
	//			int h = cvRound(x.ptr<float>(0)[3] * (float)image.rows);

	//			int left = cx - w / 2;
	//			int top = cy - h / 2;

	//			classIds.push_back(classIdPoint.x);
	//			confidences.push_back((float)confidence);
	//			bboxes.push_back(cv::Rect(left, top, w, h));
	//		}
	//	}
	//}

	////cv::Mat showMat;
	////cv::cvtColor(image)

	//std::vector<int> indices;
	////非极大值抑制
	//cv::dnn::NMSBoxes(bboxes, confidences, 0.01f, 0.05f, indices);

	//for (int i = 0; i < indices.size(); i++) {
	//	int idx = indices[i];
	//	cv::Rect bbox = bboxes[idx] & cv::Rect(0, 0, image.cols, image.rows);
	//	//标签
	//	std::string label = cv::format("%.2f", confidences[idx]);

	//	if (!classes.empty()) {
	//		label = classes[classIds[idx]] + ":" + label;
	//	}

	//	int baseLine;
	//	cv::Size labelSize = cv::getTextSize(label, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);

	//	cv::Scalar pal(0, 255, 0);

	//	cv::rectangle(image, bbox, pal);
	//	cv::rectangle(image, cv::Point(bbox.x, bbox.y - labelSize.height - baseLine), cv::Point(bbox.x + labelSize.width, bbox.y), pal, cv::FILLED);
	//	cv::putText(image, label, cv::Point(bbox.tl().x, bbox.tl().y - baseLine), cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(0, 0, 0), 1);
	//}

	/////<输出计数结果标记图像
	//{
	//	tpDstImg->iWidth = image.cols; tpDstImg->iHeight = image.rows; tpDstImg->iDepth = image.depth(); tpDstImg->iChannels = image.channels();

	//	//内存尺寸
	//	int _Size = tpDstImg->iWidth*tpDstImg->iHeight*tpDstImg->iChannels * sizeof(uint8_t);

	//	//分配初始化内存
	//	tpDstImg->vpImage = (uint8_t *)malloc(_Size);
	//	if (NULL == tpDstImg->vpImage)
	//		return FUNC_NOT_ENOUGH_MEM;
	//	memset(tpDstImg->vpImage, 0, _Size);

	//	//拷贝数据
	//	memcpy(tpDstImg->vpImage, image.data, _Size);
	//}

#pragma endregion

	return FUNC_OK;
}