#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;

void  hough_coord(Mat image, Mat& acc_mat, double rho, double theta)
{
	int  acc_h = int((image.rows + image.cols) * 2 / rho); // 피타고라스 정리로 구한 수직선보다 살짝 더 큰 범위인 width + height로 범위를 설정
	int  acc_w = int(CV_PI / theta);

	acc_mat = Mat(acc_h, acc_w, CV_32S, Scalar(0));

	for (int i = 0; i < image.rows; i++) {
		for (int j = 0; j < image.cols; j++)
		{
			Point pt(j, i); // 조회 좌표
			if (image.at<uchar>(pt) > 0) { // 직선 여부 검사

				for (int t = 0; t < acc_w; t++) // 행렬의 인덱스이므로 라디안이 필요
				{
					// pt(j, i)가 0보다 큰 값은 곧, 점을 뜻하므로, 점을 지나는 직선 방정식 구하기
					double radian = t * theta;
					double r = pt.x * cos(radian)+ pt.y * sin(radian);
					r = cvRound(r / rho + acc_mat.rows / 2.0); // rho를 나누는 이유는 theta와 같은 이유(허프 좌표계에서 y값 역시 그냥 상수이지만, 좌표로 봤을 때는 인덱스값이기 때문에)
					acc_mat.at<int>((int)r, t)++;
				}
			}
		}
	}
}

void acc_mask(Mat acc_mat, Mat& acc_dst, Size size, int thresh)
{
	acc_dst = Mat(acc_mat.size(), CV_32S, Scalar(0)); // 마스크 적용 후의 결과영상 구하기
	Point h_m = size / 2;	// 마스크 크기 절반

	for (int r = h_m.y; r < acc_mat.rows - h_m.y; r++) {
		for (int t = h_m.x; t < acc_mat.cols - h_m.x; t++)
		{
			Point center = Point(t, r) - h_m;
			int c_value = acc_mat.at<int>(center);	// 입력영상(아까 위에서 만들어준 누적 허프 변환 행렬)의 중심화소
			if (c_value >= thresh)
			{
				// 마스크만큼 정해준 영역에 대해서 순회하면서
				double maxVal = 0;
				for (int u = 0; u < size.height; u++) {
					for (int v = 0; v < size.width; v++)
					{
						Point start = center + Point(v, u);
						if (start != center && maxVal < acc_mat.at<int>(start))
							maxVal = acc_mat.at<int>(start);
					}
				}

				// 정해준 영역에서 가장 큰 값만 남기고, 나머지는 0으로 변환
				Rect rect(center, size);
				if (c_value >= maxVal)
				{
					acc_dst.at<int>(center) = c_value;
					acc_mat(rect).setTo(0);
				}
			}
		}
	}
}

// 아까와 반대의 메커니즘
// 아까는 실좌표계에서 허프 변환 좌표계로 변환하는 과정이었다면,
// 여기서부터는 다시 마스크를 씌운 허프 변환 좌표계에서 구한 제일 가능성 높은 직선들을 다시 실좌표계로 변환하는 과정
void thres_lines(Mat acc_dst, Mat& lines, double _rho, double theta, int thresh)
{
	for (int r = 0; r < acc_dst.rows; r++) {
		for (int t = 0; t < acc_dst.cols; t++)
		{
			float value = (float)acc_dst.at<int>(r, t);			// 누적값
			if (value >= thresh)								// 직선 길이 임계값
			{
				float rho = (float)((r - acc_dst.rows / 2) * _rho); // 수직거리 -> 위에 과정과 반대, 아까 acc_dst.rows / 2를 더했던 이유는 rho값이 음수가 될 수 있기 때문에
																	// 더했지만, 이번에는 반대로 실좌표계이므로 음수가 나와도 되기에 빼는 것. 또한, 다시 _rho를 아까는 곱했다면 이번에는 다시 나누기
				float radian = (float)(t * theta); // 각도

				Matx13f line(rho, radian, value); 				// 단일 직선
				lines.push_back((Mat)line);
			}
		}
	}
}

// lines에는 라디안(theat)값과 로우값들이 있음 -> 위에서 벡터 형태로 쌓았기 때문에
// sorting을 하는 이유는, 여러 개의 직선이 생기는 데, 그 중 몇 개만 추출하고 싶을 때를 위해서
void sort_lines(Mat lines, vector<Vec2f>& s_lines)
{
	Mat acc = lines.col(2), idx;
	sortIdx(acc, idx, SORT_EVERY_COLUMN + SORT_DESCENDING);

	for (int i = 0; i < idx.rows; i++)
	{
		int id = idx.at<int>(i);
		float rho = lines.at<float>(id, 0);		// 로우 값
		float radian = lines.at<float>(id, 1); // 라디안 값
		s_lines.push_back(Vec2f(rho, radian)); // 정렬된 직선 벡터 - 누적값 내림차순
	}
}

void houghLines(Mat src, vector<Vec2f>& s_lines, double rho, double theta, int thresh)
{
	Mat  acc_mat, acc_dst, lines;
	hough_coord(src, acc_mat, rho, theta);
	acc_mask(acc_mat, acc_dst, Size(3, 7), thresh);

	thres_lines(acc_dst, lines, rho, theta, thresh);
	sort_lines(lines, s_lines);
}

void draw_houghLines(Mat image, Mat& dst, vector<Vec2f> lines, int nline)
{
	if (image.channels() == 3)	image.copyTo(dst);
	else 						cvtColor(image, dst, COLOR_GRAY2BGR);

	for (int i = 0; i < min((int)lines.size(), nline); i++)
	{
		float rho = lines[i][0], theta = lines[i][1];
		double a = cos(theta), b = sin(theta);

		Point2d delta(1000 * -b, 1000 * a);
		Point2d pt(a * rho, b * rho);
		line(dst, pt + delta, pt - delta, Scalar(0, 255, 0), 1, LINE_AA);
	}
}

int main()
{
	Mat image = imread("../image/hough_test.jpg", 0);
	CV_Assert(image.data);

	Mat canny, dst1, dst2;
	GaussianBlur(image, canny, Size(5, 5), 2, 2);
	Canny(canny, canny, 100, 150, 3);

	double rho = 1, theta = CV_PI / 180;

	vector<Vec2f> lines1, lines2;
	houghLines(canny, lines1, rho, theta, 50);
//	HoughLines(canny, lines2, rho, theta, 50);
	draw_houghLines(canny, dst1, lines1, 10);
//	draw_houghLines(canny, dst2, lines2, 10);

	imshow("source", image);
	imshow("canny", canny);
	imshow("detected lines", dst1);
//	imshow("detected lines_OpenCV", dst2);
	waitKey();
}

#include <opencv2/opencv.hpp>
using namespace std;
using namespace cv;

int main(void) {
	Mat src = imread("../image/test.jpg", IMREAD_GRAYSCALE);
	CV_Assert(src.data);

	Mat blurred;
	medianBlur(blurred, src, 5);

	Mat dst;
	cvtColor(src, dst, COLOR_GRAY2BGR);

	vector<Vec3f> circles;
	HoughCircles(blurred, circles, HOUGH_GRADIENT, 1, 20, 50, 35, 0, 0);

	for (size_t i = 0; i < circles.size(); i++) {
		Vec3i c = circles[i];
		Point center(c[0], c[1]);
		int radius = c[2];
		circle(src, center, radius, Scalar(0, 0, 255), 2);
		circle(src, center, 2, Scalar(0, 0, 255), 3);
	}

	imshow("src", src);
	imshow("dst", dst);
	waitKey(0);
	return 0;
}

#include "hough.hpp"

// 가장 큰 객체 사각형 검색
void max_object(Mat img, Rect& rect)
{
	vector<vector<Point>> contours;
	findContours(img.clone(), contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);	// 외곽선 검출

	int max_area = 0;
	for (int i = 0; i < (int)contours.size(); i++)	// 가장 큰 영역 가져오기
	{
		Rect r = boundingRect(contours[i]);			// 외곽선 영역 포함 사각형

		// 최대 크기 사각형 찾기
		if (max_area < r.area()) {
			max_area = r.area();
			rect = r;
		}
	}
	rect = rect - Point(10, 10) + Size(20, 20);
}

int main()
{
	Rect  rect(Point(0, 0), Point(10, 10));
	Mat	gray, canny, morph, th_gray, canny_line, dst;
	double rho = 1, theta = CV_PI / 180;				// 허프변환 거리간격, 각도간격
	vector<Vec2f> lines;								// 허프 검출 라인들

	Mat  image = imread("../image/5.tif", 1);
	CV_Assert(image.data);
	imshow("image", image);

	cvtColor(image, gray, CV_BGR2GRAY);						// 명암도 영상 변환
	imshow("gray", gray);

	threshold(gray, th_gray, 240, 255, THRESH_BINARY);		//이진 영상 변환
	imshow("th_gray", th_gray);

	erode(th_gray, morph, Mat(), Point(-1, -1), 2);			// 침식 연산
	imshow("morph", morph);

	max_object(morph, rect);								// 가장 큰 객체 검색
	rectangle(morph, rect, Scalar(255), 2);					// 검색 객체 표시
	imshow("rect", th_gray(rect));

	// 커넥터 영역만 캐니 에지 수행
	Canny(th_gray(rect), canny, 40, 100);
	houghLines(canny, lines, rho, theta, 50);
	draw_houghLines(canny, canny_line, lines, 1);
	imshow("line", canny_line);

	double angle = (CV_PI - lines[0][1]) * 180 / CV_PI; // lines[0][1]에는 theta값이 들어있음 -> 회전 각은 왜 이렇게 되나?
	Point  center = image.size() / 2;
	Mat rot_map = getRotationMatrix2D(center, -angle, 1);
	warpAffine(image, dst, rot_map, image.size(), INTER_LINEAR);
	imshow("dst", dst);

	resizeWindow("line", 150, 150);
	waitKey(0);
	return 0;
}

#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;

void cornerharris(Mat image, Mat& corner, int bSize, int ksize, float k)
{
	Mat dx, dy, dxy, dx2, dy2;
	corner = Mat(image.size(), CV_32F, Scalar(0));

	vector<int> a;

	Sobel(image, dx, CV_32F, 1, 0, ksize);
	Sobel(image, dy, CV_32F, 0, 1, ksize);

	multiply(dx, dx, dx2);
	multiply(dy, dy, dy2);
	multiply(dx, dy, dxy);

	// 미분 행렬 제곱
	Size msize(5, 5);
	GaussianBlur(dxy, dxy, msize, 0);
	GaussianBlur(dx2, dx2, msize, 0);
	GaussianBlur(dy2, dy2, msize, 0);

	for (int i = 0; i < image.rows; i++) {
		for (int j = 0; j < image.cols; j++)
		{
			float  a = dx2.at<float>(i, j);
			float  b = dy2.at<float>(i, j);
			float  c = dxy.at<float>(i, j);
			corner.at<float>(i, j) = (a * b - c * c) - k * (a + b) * (a + b);
		}
	}
}

Mat draw_coner(Mat corner, Mat image, int thresh)
{
	int cnt = 0;
	normalize(corner, corner, 0, 100, NORM_MINMAX, CV_32FC1, Mat());

	for (int i = 1; i < corner.rows - 1; i++) {
		for (int j = 1; j < corner.cols - 1; j++)
		{
			float cur = (int)corner.at<float>(i, j);
			if (cur > thresh)
			{
				if (cur > corner.at<float>(i-1, j) &&
					cur > corner.at<float>(i, j-1) &&
					cur > corner.at<float>(i+1, j) &&
					cur > corner.at<float>(i, j+1))
				{
					circle(image, Point(j, i), 2, Scalar(255, 0, 0), -1);
					cnt++;
				}
			}
		}
	}
	cout << "코너수: " << cnt << endl;
	return image;
}

Mat image, corner1, corner2;

void cornerHarris_demo(int  thresh, void*)
{
	Mat img1 = draw_coner(corner1, image.clone(), thresh);
	Mat img2 = draw_coner(corner2, image.clone(), thresh);

	imshow("img1-User harris", img1);
	imshow("img2-OpenCV harris", img2);
}

int main()
{
	image = imread("../image/harris_test.jpg", 1);			// 컬러 영상입력
	CV_Assert(image.data);

	int blockSize = 4;
	int apertureSize = 3;
	double k = 0.04;
	int  thresh = 20;
	Mat gray;

	cvtColor(image, gray, CV_BGR2GRAY);
	cornerharris(gray, corner1, blockSize, apertureSize, k); 	// 직접 구현 함수
	cornerHarris(gray, corner2, blockSize, apertureSize, k);	// OpenCV 제공 함수

	cornerHarris_demo(0, 0);
	createTrackbar("Threshold: ", "img1-User harris", &thresh, 100, cornerHarris_demo);
	waitKey();
}

#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;

void make_tranData(Mat trainData, Mat group[2], Mat& classLable)
{
   int half = trainData.rows / 2;
   Range r1(0, half);
   Range r2(half, trainData.rows);

   group[0] = trainData.rowRange(r1);
   group[1] = trainData.rowRange(r2);

   randn(group[0], 150, 50);
   randn(group[1], 250, 50);
   classLable.rowRange(r1).setTo(0);
   classLable.rowRange(r2).setTo(1);
}


// group[0]은 빨간색 원(윗쪽)
// group[1]은 초록색 원(아랫쪽)
void draw_points(Mat& image, Mat group[2])
{
   for (int i = 0; i < group[0].rows; i++)
   {
      Point2f pt1(group[0].at<float>(i, 0), group[0].at<float>(i, 1)); // 윗부분 (x, y)
      Point2f pt2(group[1].at<float>(i, 0), group[1].at<float>(i, 1)); // 아랫부분 (x, y)
      circle(image, pt1, 3, Scalar(0, 0, 255), FILLED);
      circle(image, pt2, 3, Scalar(0, 255, 0), FILLED);
   }
}

int main()
{
   int Nsample = 100;
   Mat trainData(Nsample, 2, CV_32FC1, Scalar(0));
   Mat classLable(Nsample, 1, CV_32FC1, Scalar(0));
   Mat image(400, 400, CV_8UC3, Scalar(255, 255, 255));

   Mat group[2];
   make_tranData(trainData, group, classLable);
   draw_points(image, group);
   imshow("학습데이터", image);
   waitKey();
   return 0;
}

// KNearst 클래스
#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;

void make_trainData(Mat trainData, Mat group[2], Mat& classLable)
{
   int half = trainData.rows / 2;
   Range r1(0, half);
   Range r2(half, trainData.rows);

   group[0] = trainData.rowRange(r1);
   group[1] = trainData.rowRange(r2);
   randn(group[0], 150, 50);
   randn(group[1], 250, 50);
   classLable.rowRange(r1).setTo(0);
   classLable.rowRange(r2).setTo(1);
}

void draw_points(Mat& image, Mat group[2])
{
   for (int i = 0; i < group[0].rows; i++)
   {
      Point2f pt1(group[0].at<float>(i, 0), group[0].at<float>(i, 1));
      Point2f pt2(group[1].at<float>(i, 0), group[1].at<float>(i, 1));
      circle(image, pt1, 3, Scalar(0, 0, 255), FILLED);
      circle(image, pt2, 3, Scalar(0, 255, 0), FILLED);
   }
}

void kNN_test(Ptr<ml::KNearest>  knn, int K, Mat& image)
{
   for (int y = 0; y < image.rows; y++) {
      for (int x = 0; x < image.cols; x++)
      {
         Matx12f sample((float)x, (float)y);
         Mat response;
         knn->findNearest(sample, K, response); // 분류 수행

         int resp = (int)response.at<float>(0);
         if (resp == 1)   image.at<Vec3b>(y, x) = Vec3b(0, 180, 0);
         else         image.at<Vec3b>(y, x) = Vec3b(0, 0, 180);
      }
   }
}

int main()
{
   int Nsample = 100;
   Mat trainData(Nsample, 2, CV_32FC1, Scalar(0));
   Mat classLable(Nsample, 1, CV_32FC1, Scalar(0));

   Mat group[2];
   make_trainData(trainData, group, classLable);

   Mat image(400, 400, CV_8UC3, Scalar(255, 255, 255));

   int K = 7;
   Ptr<ml::KNearest>  knn = ml::KNearest::create();
   knn->train(trainData, ml::ROW_SAMPLE, classLable);
   kNN_test(knn, K, image);

   draw_points(image, group);
   imshow("sample K=" + to_string(K), image);
   waitKey();
   return 0;
}

#include "kNN.hpp"

int main()
{
   Size  size(40, 40);      // 학습 셀 크기 
   int  K = 15;         // 선출하는 이웃 샘플수
   int  Nclass = 10;      // 인식 숫자(카테고리) 개수
   int  Nsample = 20;      // 숫자당 학습 샘플수

   string image_file = "../image/train_numbers.png";
   Mat  train_image = imread(image_file, 0);      // 영상 로드
   CV_Assert(train_image.data);

   threshold(train_image, train_image, 32, 255, CV_THRESH_BINARY);

   Mat  trainData, classLable;
   for (int i = 0, k = 0; i < Nclass; i++) {
      for (int j = 0; j < Nsample; j++, k++)
      {
         Point start(j * size.width, i * size.height);
         Rect  roi(start, size);
         Mat   part = train_image(roi);         // 숫자 영상 분리

         Mat  num = find_number(part);      // 숫자 영역 영상
         Mat  data = place_middle(num, size);   // 정규화 및 1행데이터 구성
         trainData.push_back(data);      // 학습 데이터 수집
         classLable.push_back(i);      // 레이블링
      }
   }

   Ptr<ml::KNearest>  knn = ml::KNearest::create();
   knn->train(trainData, ml::ROW_SAMPLE, classLable);   // k-NN 학습


   int no;
   cout << "영상번호를 입력하세요: ";
   cin >> no;                           // 영상번호 입력

   string demo_file = format("../image/num/%02d.png", no);
   Mat  test_img = imread(demo_file, 0);         // 실험 영상 로드
   CV_Assert(test_img.data);                  // 예외처리

   threshold(test_img, test_img, 128, 255, THRESH_BINARY);   // 이진화
   Mat  num = find_number(test_img);      // 숫자객체 검출
   Mat  data = place_middle(num, size);         // 숫자객체 셀 중심 배치 

   Mat result;
   knn->findNearest(data, K, result);            // 숫자 분류 수행

   cout << "분류결과 : " << result.at<float>(0) << endl;

   imshow("test_img", test_img);
   waitKey();
   return 0;
}

#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;

Point2f pt1, pt2;
Mat image;

void morphing()
{
   Mat dst(image.size(), image.type(), Scalar(0));
   int  width = image.cols;
   int height = image.rows;

   for (float y = 0; y < image.rows; y += 0.1f) {
      for (float x = 0; x < image.cols; x += 1) // x가 0.1인 이유는 값이 너무 크면 홀이 생겨버리기 때문에
      {
         float ratio;
         if (y < pt1.y) {
            ratio = y / pt1.y;
         }
         else {
            ratio = (height - y) / (height - pt1.y);
         }

         /*
         if (x < pt1.x) {
            ratio = x / pt1.x;
         }
         else {
            ratio = (width - x) / (width - pt1.x);
         }

         float dx = ratio * (pt2.x - pt1.x);
         float dy = ratio * (pt2.y - pt1.y);

         dst.at<uchar>(y, x + dx) = image.at<uchar>(y, x); // 역방향 사상
//         dst.at<uchar>(y + dy, x) = image.at<uchar>(y, x); // 역방향 사상
      }
   }
   dst.copyTo(image);
   imshow("image", image);
}

void onMouse(int event, int x, int y, int flags, void* param)
{
   if (event == EVENT_LBUTTONDOWN) {
      pt1 = Point2f(x, y);
   }
   else if (event == EVENT_LBUTTONUP) {
      pt2 = Point2f(x, y);
      morphing();
   }
}

int main()
{
   image = imread("../image/warp_test.jpg", 0);
   CV_Assert(image.data);

   imshow("image", image);
   setMouseCallback("image", onMouse);
   waitKey();

   return 0;
}