#include "mvpt_process_assist.h"

int minDistance[EDGESIZE];

//******** 判断位置是否合法函数 **********//
// 目的：剔除掉靠近摄像头时，面积最大，但是检测物体已经不完整的情况
// 1. 设定阈值，靠近边缘不要了（阈值目前设定为自身宽高的20%）
bool LegalPos(bitset<EDGESIZE> flags, int left, int top, int right, int bottom, int imgHeight, int imgWidth)
{
	int pos[4] = { left, top, right, bottom };
	int edges[4] = { 0, 0, imgWidth, imgHeight };

	for (int i = 0; i < EDGESIZE; i++)
	{
		if (flags[i])  //是需要判断的边
		{
			if (abs(pos[i] - edges[i]) < minDistance[i])
				return false;
		}
	}
	return true;
}

bool LegalMinArea(int width, int height, sy_rect min_box)
{
	return (width >= min_box.width_ && height >= min_box.height_);
}

//******** 判断面积是否合法函数 **********//
// 目的：选取框最大最完整的那帧
// 1. 比之前面积小的不要
// 2. 突变的面积不要
bool LegalArea(int maxArea, int lastArea, int left, int top, int right, int bottom)
{
	//不需要通过MINBOX来判断，直接返回true

	int newArea = (bottom - top)*(right - left);

	if (lastArea == 0)
		return true;

	if (newArea < maxArea)
		return false;
	else if ((newArea - lastArea) / lastArea > 0.5)  //阈值测试之后再确定，看是否需要分种类来确定不同的阈值
		return false;
	else return true;
}


//******** 辅助函数：根据目标运动的轨迹，判断需要特别外扩的方向 **********//
// 目的：因为跳帧的存在，目标运动较快时，框会有一定的滞后的情况（车向前运动，车头被裁掉的情况尤其明显），框滞后的方向需要额外外扩
void ExpandMargin(int direction_x, int direction_y, int boundary_w, int boundary_h,
	int &boundary_left, int &boundary_right, int &boundary_top, int &boundary_bottom)
{
	if (abs(direction_x) > abs(direction_y))
	{
		if (direction_x > 0)
		{
			boundary_right = 2.5 * boundary_w;
		}
		else
		{
			boundary_left = 2.5 * boundary_w;
		}
	}
	else
	{
		if (direction_y > 0)
		{
			boundary_bottom = 2.5 * boundary_h;
		}
		else
		{
			boundary_top = 2.5 * boundary_h;
		}
	}
	/*int max_dis = max(max(max(dis_left, dis_right), dis_top), dis_bottom);

	if (max_dis == dis_left)
	boundary_left = 3 * boundary_w;
	else if (max_dis == dis_right)
	boundary_right = 3 * boundary_w;
	else if (max_dis == dis_top)
	boundary_top = 3 * boundary_h;
	else
	boundary_bottom = 3 * boundary_h;*/
}

int CreateDir(char *pszDir)
{
	int i = 0;
	int iRet;
	int iLen = strlen(pszDir);
	if (pszDir[iLen - 1] != '\\' && pszDir[iLen - 1] != '/')
	{
		pszDir[iLen] = '/';
		pszDir[iLen + 1] = '\0';
	}
	iLen = strlen(pszDir);

	if (iLen > 2 && ((pszDir[i] == '\\' && pszDir[i + 1] == '\\') || (pszDir[i] == '/' && pszDir[i + 1] == '/')))
	{
		i = 2;
		for (; i <= iLen; i++)
			if (pszDir[i] == '\\' || pszDir[i] == '/')
				break;

		i++;

		for (; i <= iLen; i++)
		{
			if (pszDir[i] == '\\' || pszDir[i] == '/')
			{
				pszDir[i] = '\0';
				//printf("file access %s\n", pszDir);
				iRet = ACCESS(pszDir, 0);
				//printf("file access %d\n", iRet);
				if (iRet != 0)
				{
					//printf("file mkdir %s\n", pszDir);
					iRet = MKDIR(pszDir);
					//printf("file mkdir %d\n", iRet);
					if (iRet != 0)
					{
						printf("Create Folder Failed!");
						return -1;
					}
				}
				pszDir[i] = '/';

			}
		}
		return 0;
	}

	if (pszDir[i] != '\\' && pszDir[i] != '/')
		i = 0;
	else
		i = 1;
	for (; i <= iLen; i++)
	{
		if (pszDir[i] == '\\' || pszDir[i] == '/')
		{
			pszDir[i] = '\0';
			//printf("file access %s\n", pszDir);
			iRet = ACCESS(pszDir, 0);
			//printf("file access %d\n", iRet);
			if (iRet != 0)
			{
				//printf("file mkdir %s\n", pszDir);
				iRet = MKDIR(pszDir);
				//printf("file mkdir %d\n", iRet);
				if (iRet != 0)
				{
					return -1;
				}
			}
			pszDir[i] = '/';

		}
	}
	return 0;
}

void CreateResultFolder(char* resultFolder, const char* jointFolder)
{
	if (strlen(resultFolder) > 240)  //?too long
	{
		printf("Folder Name is too Long!");
		return;
	}
	else if (strlen(resultFolder) < 1)  //?too short
	{
		printf("Folder Name is too Short!");
		return;
	}

	char dir[260];

	sprintf(dir, "%s%s/", resultFolder, jointFolder);
	if (CreateDir(dir) != 0)
	{
		printf("Create Folder Failed!");
		return;
	}
}

//俯仰角比较容易产生大角度 所以单独设置 一般建议阈值 max_angle 15.0 max_pitch_angle 20.0
bool validAngle(float roll, float yaw, float pitch, float max_angle, float max_pitch_angle)
{
	if (yaw >= -max_angle && yaw <= max_angle \
		&& roll >= -max_angle && roll <= max_angle \
		/*&& pitch >= -maxangle && pitch <= maxangle*/ && pitch >= -max_pitch_angle && pitch <= max_pitch_angle)
	{
		//printf("return true\n");
		return true;
	}

   	return false;
}


//俯仰角比较容易产生大角度 所以单独设置 一般建议阈值 max_angle 15.0 max_pitch_angle 20.0
bool betterArea(sy_rect& area1, sy_rect& area2)
{
	return area1.width_*area1.height_ > area2.width_*area2.height_;
}

//void showGpuMat(unsigned char* imgdata, int height, int width)
//{
//	int testWidth = width;
//	int testHeight = height;
//
//	cv::Mat host_image;
//	host_image.create(testHeight, testWidth, CV_8UC3);
//
//	unsigned char *Host_img = new unsigned char[3 * testWidth * testHeight]{};//主机内存
//
//	(cudaMemcpy(Host_img, imgdata, testWidth*testHeight * 3 * sizeof(unsigned char), cudaMemcpyDeviceToHost));//拷贝显卡处理完图像到主机
//
//	for (int j = 0; j < host_image.rows; j++)
//	{
//		uchar *pts = host_image.ptr<uchar>(j);
//		for (int i = 0; i < host_image.cols; i++)
//		{
//			//pts[3 * i] = cv::saturate_cast<uchar>(Host_img[3 * (j*host_image.cols + i) + 0]);                                     //b
//			//pts[3 * i + 1] = cv::saturate_cast<uchar>(Host_img[3 * (j*host_image.cols + i) + 1]);             //g
//			//pts[3 * i + 2] = cv::saturate_cast<uchar>(Host_img[3 * (j*host_image.cols + i) + 2]);         //r
//
//			pts[3 * i] = cv::saturate_cast<uchar>(Host_img[j * host_image.cols * 3 + i * 3]);
//			pts[3 * i + 1] = cv::saturate_cast<uchar>(Host_img[j * host_image.cols * 3 + i * 3 + 1]);
//			pts[3 * i + 2] = cv::saturate_cast<uchar>(Host_img[j * host_image.cols * 3 + i * 3 + 2]);
//
//			//pts[3 * i] = cv::saturate_cast<uchar>(Host_img[j * host_image.cols + i]);                                     //b
//			//pts[3 * i + 1] = cv::saturate_cast<uchar>(Host_img[host_image.cols * host_image.rows + j * host_image.cols + i]);             //g
//			//pts[3 * i + 2] = cv::saturate_cast<uchar>(Host_img[2 * host_image.cols * host_image.rows + j * host_image.cols + i]);         //r
//		}
//	}
//
//	cv::imshow("image", host_image);
//	cv::waitKey(0);
//}