#include <iostream>
#include "alg.h"
#include "AlgCommon.h"

/*
截图方式说明：
1.鼠标左键按下则为截图起始点
方法一：鼠标左键一直按下，直到鼠标移动到目标点再松开，即可完成一次截图；
方法二：鼠标左键单击后，鼠标移动到目标点再次鼠标左键单击，即可完成一次截图；
若是在截图过程中，单击鼠标右键可取消本次截图状态
2.截图不会立即进行保存，截完图后可以单击鼠标右键进行取消保存上一次的截图；
存储方式一：若是截图完成后，再次进入截图状态，则会自动存储上一轮截图；
存储方式二：若是跳到下一张原始图片，则上一张原始图片中未保存的上一轮截图会自动存储；
*/


#define  MIN_ROI_AREA 	300  //有效截图的最小面积限制		

//定义全局变量
static cv::Point g_pt;		//存储鼠标第一次按下的坐标，即截图的左上角坐标；
static cv::Mat g_img_src;	//存储当前的原始图像；
static cv::Mat g_img_dst;	//存储截图过程实时的图像；
static cv::Mat g_img_roi;	//存储截图完成时的局部图；
static cv::Rect roi_area;	//存储截图完成时的局部图；
static bool g_flag = false;	//是否已处于截图状态的标示	
static bool g_issave = false;	//是否已经有未存储的缓存roi的标示
static std::string g_window_name = "image";//窗口名

//保存截取的roi图像
void save_roi(cv::Mat image)
{
	//定义输出路径，imwrite()输出，略；
}

//	鼠标的回调函数
static void onMouse(int event, int x, int y, int, void*)
{
	//触发鼠标左键按下事件
	if (cv::EVENT_LBUTTONDOWN == event)
	{
		//若当前不是截图状态，则进入截图状态，当前点为起始点并存储；	
		if (g_flag == false)
		{
			//进入截图状态；
			g_flag = true;
			//存储截图起始点
			g_pt = cv::Point(x, y);

			//若未保存上一轮roi的保存，则进行存储；
			if (g_issave == true)
			{
				save_roi(g_img_roi);
				g_issave = false;
			}
		}
		//若当前处于截图状态，则结束截图状态，并获取roi
		if (g_flag == true && abs(x - g_pt.x)*abs(y - g_pt.y) > MIN_ROI_AREA)
		{
			//结束截图状态
			g_flag = false;
			// 利用截图区域生成g_img_roi
			roi_area = cv::Rect(g_pt, cv::Point(x, y));
			g_img_src(roi_area).copyTo(g_img_roi);
			//cv::imshow("roi", g_img_roi);
			g_issave = true;
		}
	}//if(CV_EVENT_LBUTTONDOWN == event)

	//触发鼠标移动事件，并处于截图状态时
	else if (cv::EVENT_MOUSEMOVE == event && g_flag)
	{
		//重新初始化g_img_dst，确保g_img_dst上始终只有一个框
		g_img_src.copyTo(g_img_dst);
		cv::rectangle(g_img_dst, g_pt, cv::Point(x, y), cv::Scalar(255, 0, 0), 3, 8);
		cv::imshow(g_window_name, g_img_dst);
	}

	//触发鼠标左键松开事件
	else if (cv::EVENT_LBUTTONUP == event &&
		abs(x - g_pt.x)*abs(y - g_pt.y) > MIN_ROI_AREA)
	{
		//结束截图状态
		g_flag = false;
		//获取roi
		roi_area = cv::Rect(g_pt, cv::Point(x, y));
		g_img_src(roi_area).copyTo(g_img_roi);
		//cv::imshow("roi", g_img_roi);
		g_issave = true;
	}

	//触发鼠标右键按下事件
	else if (cv::EVENT_RBUTTONDOWN == event)
	{
		//在截图状态，则取消截图状态
		if (g_flag == true)
		{
			g_flag = false;
			//更新图像
			cv::imshow(g_window_name, g_img_src);
		}
		//不在截图状态，则无效上一轮的截图缓存；
		if (g_flag == false)
		{
			g_issave = false;
			//更新图像
			cv::imshow(g_window_name, g_img_src);
			//关闭局部窗口
			//cv::destroyWindow("roi");
		}
	}
}

bool inline getMinMax(std::vector<cv::Point3i> &points, cv::Point3i &min, cv::Point3i &max)
{
	int minx = 0, miny = 0, minz = 0;
	int maxx = 0, maxy = 0, maxz = 0;

	for (int i = 0; i < points.size(); i++) {
		if (points[i].x < minx)minx = points[i].x;
		if (points[i].y < miny)miny = points[i].y;
		if (points[i].z < minz)minz = points[i].z;
		if (points[i].x > maxx)maxx = points[i].x;
		if (points[i].y > maxy)maxy = points[i].y;
		if (points[i].z > maxz)maxz = points[i].z;
	}
	
	min.x = minx;
	min.y = miny;
	min.z = minz;
	max.x = maxx;
	max.y = maxy;
	max.z = maxz;

	return true;
}

bool Alg::ScreenShot(cv::Mat imgfull)
{
	cv::namedWindow(g_window_name, cv::WINDOW_AUTOSIZE);
	cv::setMouseCallback(g_window_name, onMouse, 0);
	cv::Mat img = imgfull;

	if (img.empty())
	{
		std::cout << "empty image" << std::endl;
		return false;
	}
	//存储原始图像
	g_img_src = img.clone();
	cv::imshow(g_window_name, g_img_src);

	while (1) { 
		cv::waitKey(100);
		if(g_issave)break;
	}
	//图像选择窗口
	cv::destroyWindow(g_window_name);

	img = g_img_roi.clone();
	if (img.empty())
	{
		std::cout << "empty roi image" << std::endl;
		return false;
	}

	RefRect = roi_area;
	return true;
}

//*****************图像移位函数*******************
void dftshift(cv::Mat &img_r, cv::Mat &img_i)
{
	int cx = img_r.cols / 2;
	int cy = img_r.rows / 2;//以下的操作是移动图像  (零频移到中心)
	cv::Mat part1_r(img_r, cv::Rect(0, 0, cx, cy));  //元素坐标表示为(cx,cy)
	cv::Mat part2_r(img_r, cv::Rect(cx, 0, cx, cy));
	cv::Mat part3_r(img_r, cv::Rect(0, cy, cx, cy));
	cv::Mat part4_r(img_r, cv::Rect(cx, cy, cx, cy));

	cv::Mat temp;
	part1_r.copyTo(temp);  //左上与右下交换位置(实部)
	part4_r.copyTo(part1_r);
	temp.copyTo(part4_r);

	part2_r.copyTo(temp);  //右上与左下交换位置(实部)
	part3_r.copyTo(part2_r);
	temp.copyTo(part3_r);

	cv::Mat part1_i(img_i, cv::Rect(0, 0, cx, cy));  //元素坐标(cx,cy)
	cv::Mat part2_i(img_i, cv::Rect(cx, 0, cx, cy));
	cv::Mat part3_i(img_i, cv::Rect(0, cy, cx, cy));
	cv::Mat part4_i(img_i, cv::Rect(cx, cy, cx, cy));

	part1_i.copyTo(temp);  //左上与右下交换位置(虚部)
	part4_i.copyTo(part1_i);
	temp.copyTo(part4_i);

	part2_i.copyTo(temp);  //右上与左下交换位置(虚部)
	part3_i.copyTo(part2_i);
	temp.copyTo(part3_i);
}
//*****************频率域滤波*******************
cv::Mat freqfilt(cv::Mat &scr, cv::Mat &blur)
{
	cv::Mat img_r = scr.clone();
	cv::Mat img_i = cv::Mat::zeros(scr.size(), CV_32FC1);
	//***********************DFT*******************
	cv::Mat plane[] = { img_r, img_i}; //创建通道，存储dft后的实部与虚部（CV_32F，必须为单通道数）
	cv::Mat complexIm;
	merge(plane, 2, complexIm);//合并通道 （把两个矩阵合并为一个2通道的Mat类容器）
	dft(complexIm, complexIm);//进行傅立叶变换，结果保存在自身

	//***************中心化********************
	split(complexIm, plane);//分离通道（数组分离）
    //plane[0] = plane[0](cv::Rect(0, 0, plane[0].cols & -2, plane[0].rows & -2));//这里为什么&上-2具体查看opencv文档
//    //其实是为了把行和列变成偶数 -2的二进制是11111111.......10 最后一位是0
	dftshift(plane[0], plane[1]);

	//*****************滤波器函数与DFT结果的乘积****************
	cv::Mat BLUR;
	{
		cv::Mat blur_r, blur_i;
		multiply(plane[0], blur, blur_r); //滤波（实部与滤波器模板对应元素相乘）
		multiply(plane[1], blur, blur_i);//滤波（虚部与滤波器模板对应元素相乘）
		cv::Mat plane1[] = { blur_r, blur_i };
		merge(plane1, 2, BLUR);//实部与虚部合并
	}
	//*********************得到原图频谱图***********************************
	//magnitude(plane[0], plane[1], plane[0]);//获取幅度图像，0通道为实部通道，1为虚部，因为二维傅立叶变换结果是复数
	//plane[0] += cv::Scalar::all(1);  //傅立叶变换后的图片不好分析，进行对数处理，结果比较好看
	//log(plane[0], plane[0]);    // float型的灰度空间为[0，1])
	//normalize(plane[0], plane[0], 1, 0, cv::NORM_MINMAX);  //归一化便于显示
	//cv::Mat iiimg=plane[0];
    //imshow("原图像频谱图",plane[0]);

	idft(BLUR, BLUR);    //idft结果也为复数
	split(BLUR, plane);//分离通道，主要获取通道
	magnitude(plane[0], plane[1], plane[0]);  //求幅值(模)
	normalize(plane[0], plane[0], 1, 0, cv::NORM_MINMAX);  //归一化便于显示
	return plane[0];//返回参数
}

cv::Mat ideal_lbrf_kernel(cv::Mat &scr, float sigma)
{
	cv::Mat ideal_low_pass(scr.size(), CV_32FC1); //，CV_32FC1
	cv::Mat gauss_low_pass(scr.size(), CV_32FC1); //，CV_32FC1
	cv::Mat gauss_high_pass(scr.size(), CV_32FC1); //，CV_32FC1
	////*****************理想低通滤波器***********************
	//float d0 = sigma;//半径D0越小，模糊越大；半径D0越大，模糊越小
	//for (int i = 0; i < scr.rows; i++) {
	//	for (int j = 0; j < scr.cols; j++) {
	//		double d = sqrt(pow((i - scr.rows / 2), 2) + pow((j - scr.cols / 2), 2));//分子,距离频率中心的距离,计算pow必须为float型
	//		if (d <= d0) {
	//			ideal_low_pass.at<float>(i, j) = 1;
	//		}
	//		else {
	//			ideal_low_pass.at<float>(i, j) = 0;
	//		}
	//	}
	//}
	//std::string name = "理想低通滤波器d0=" + std::to_string(sigma);
	//*****************高斯带通低通滤波器***********************
	//float sigma_gauss_low = sigma;
	//for (int i = 0; i < scr.rows; i++) {
	//	for (int j = 0; j < scr.cols; j++) {
	//		double d = sqrt(pow((i - scr.rows / 2), 2) + pow((j - scr.cols / 2), 2));//分子,计算pow必须为float型
	//		double gauss_value = -1 * pow(d, 2) / (2 * pow(sigma_gauss_low, 2));
	//		gauss_value = pow(2.718281828459, gauss_value);
	//		gauss_low_pass.at<float>(i, j) = gauss_value;
	//	}
	//}
	//name = "高斯低通滤波器d0=" + std::to_string(sigma);
	//*****************高斯带通高通滤波器***********************
	float sigma_gauss_high = sigma;
	for (int i = 0; i < scr.rows; i++) {
		for (int j = 0; j < scr.cols; j++) {
			double d = sqrt(pow((i - scr.rows / 2), 2) + pow((j - scr.cols / 2), 2));//分子,计算pow必须为float型
			double gauss_value = -1 * pow(d, 2) / (2 * pow(sigma_gauss_high, 2));
			gauss_value = pow(2.718281828459, gauss_value);
			gauss_high_pass.at<float>(i, j) = 1-gauss_value;
		}
	}
	//name = "高斯低通滤波器d0=" + std::to_string(sigma);

	return gauss_high_pass;
}

cv::Mat ideal_Low_Pass_Filter(cv::Mat &src, float sigma)
{
	int M = cv::getOptimalDFTSize(src.rows);
	int N = cv::getOptimalDFTSize(src.cols);
	cv::Mat padded;                 //调整图像加速傅里叶变换
	copyMakeBorder(src, padded, 0, M - src.rows, 0, N - src.cols, cv::BORDER_CONSTANT, cv::Scalar::all(0));
	padded.convertTo(padded, CV_32FC1); //将图像转换为flaot型

	cv::Mat ideal_kernel = ideal_lbrf_kernel(padded, sigma);//理想低通滤波器
	cv::Mat result = freqfilt(padded, ideal_kernel);
	return result;
}

void Alg::process_2dfft(cv::Mat &input,cv::Mat &output)
{
	double t = (double)cv::getTickCount();

	cv::Mat img_clone = input.clone();
	resize(img_clone, input,cv::Size(512,512));
	cv::Mat img_thr;
	threshold(img_clone, img_thr, 200, 255, cv::THRESH_TOZERO_INV);
	threshold(img_thr, img_thr, 50, 255, cv::THRESH_BINARY);

	cv::Mat pro_src = img_thr.clone();
	fistEROthenDIL(pro_src,3, 3);
	//查找轮廓
	double maxarea = 0;
	int maxAreaIdx = 0;
	std::vector<std::vector<cv::Point> > contours_pre;
	std::vector < cv::Vec4i > hierarchy_pre;
	cv::findContours(pro_src, contours_pre, hierarchy_pre, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
	for (int i = 0; i < contours_pre.size(); i++)
	{
		double tmparea = fabs(contourArea(contours_pre[i]));
		if (tmparea > maxarea)
		{
			maxarea = tmparea;
			maxAreaIdx = i;//记录最大轮廓的索引号  
		}
	}

	cv::Mat second_input;
	if (contours_pre.size())
	{
		cv::Rect rect_pre = cv::boundingRect(contours_pre[maxAreaIdx]);
		second_input = img_clone(rect_pre).clone();
	}
	else
	{
		second_input = img_clone;
	}


	cv::Mat ideal = ideal_Low_Pass_Filter(second_input, 30);
	ideal = ideal(cv::Rect(0, 0, second_input.cols, second_input.rows));

	cv::Mat third_input;
	normalize(ideal, third_input, 0, 255, cv::NORM_MINMAX);
	third_input.convertTo(third_input, CV_8UC1);
	threshold(third_input, third_input, 10, 255, cv::THRESH_BINARY);
	fistEROthenDIL(third_input, 3, 5);

	output = third_input.clone();
	cv::waitKey(1);

	t = ((double)cv::getTickCount() - t) / cv::getTickFrequency();
	std::cout << "cost time\t" << t <<" s" << std::endl;
}

bool Alg::process_bool(cv::Mat &input, cv::Mat &output)
{
	double t = (double)cv::getTickCount();

	cv::Mat img_clone = input.clone();
	cv::Mat img_input;
	threshold(img_clone, img_clone, 200, 0, cv::THRESH_TOZERO_INV);
	threshold(img_clone, img_input, 90, 0, cv::THRESH_TOZERO);
	// third_input.convertTo(third_input, CV_8UC1);

	fistEROthenDIL(img_input, 13, 13);

	// output = third_input.clone();

	// //查找轮廓
	// cv::Mat temp = third_input.clone();
	// double maxarea = 0;
	// int maxAreaIdx = 0;
	// std::vector<std::vector<cv::Point> > contours_pre;
	// std::vector < cv::Vec4i > hierarchy_pre;
	// cv::findContours(temp, contours_pre, hierarchy_pre, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
	// for (int i = 0; i < contours_pre.size(); i++)
	// {
	// 	drawContours(temp, contours_pre, i, cv::Scalar(255), 2, 8, hierarchy_pre);
	// 	double tmparea = fabs(contourArea(contours_pre[i]));
	// 	if (tmparea > maxarea)
	// 	{
	// 		maxarea = tmparea;
	// 		maxAreaIdx = i;//记录最大轮廓的索引号  
	// 	}
	// }
	
	t = ((double)cv::getTickCount() - t) / cv::getTickFrequency();
	std::cout << "cost time\t" << t << " s" << std::endl;
	return 1;
}