#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

#include <iostream>
#include <vector>

using namespace std;
using namespace cv;


void question1(Mat image) {
	if (image.channels() >= 3) {
		vector <Mat> rgb(image.channels());
		namedWindow("original");
		imshow("original", image);
		split(image, rgb);
		namedWindow("b");
		imshow("b", rgb[0]);
		namedWindow("g");
		imshow("g", rgb[1]);
		namedWindow("r");
		imshow("r", rgb[2]);
		waitKey(0);

	}
}

void question2(Mat image) {
	if (image.channels() >= 3) {
		Mat fin;
		vector <Mat> hsv(image.channels());
		cvtColor(image, fin, CV_BGR2HSV);
		split(fin, hsv);
		imshow("Hue Channel", hsv[0]);
		imshow("Saturation Channel", hsv[1]);
		imshow("Value Channel", hsv[2]);
		waitKey(0);
	}
}

void question3(Mat image) {
	if (image.channels() >= 3) {
		Mat fin;
		vector <Mat> lab(image.channels());
		cvtColor(image, fin, CV_BGR2Lab);
		split(fin, lab);
		imshow("L", lab[0]);
		imshow("a", lab[1]);
		imshow("b", lab[2]);
		waitKey(0);
	}
}

void question4(Mat image) {
	if (image.channels() >= 3) {
		Mat fin;
		cvtColor(image, fin, CV_BGR2GRAY);
		namedWindow("GreyScale");
		imshow("GreyScale", fin);
		waitKey(0);
	}
}

void question7a(Mat image) {
	if (image.empty()) {
		cout << "Could not load image";
		system("pause");
	}
	else {
		Mat fin;
		cvtColor(image, fin, CV_BGR2GRAY);
		Mat hist;
		equalizeHist(fin, hist);
		namedWindow("original");
		imshow("original", image);
		namedWindow("grey");
		imshow("grey", fin);
		namedWindow("hist");
		imshow("hist", hist);
		waitKey(0);
	}

}

void question5() {
	Mat image;
	image = imread("C:/Users/siddartha/Pictures/selfie.jpg");
	if (image.empty()) {
		cout << "Image could not be loaded";
		system("pause");
		return;
	}

	Mat skin;
	blur(image, skin, Size(1, 1));
	cvtColor(skin, skin, CV_BGR2HSV);
	Mat bw;
	inRange(skin, Scalar(0, 10, 60), Scalar(50, 250, 255), bw);
	vector <Mat> hsv(skin.channels());
	vector <Mat> bin(bw.channels());
	split(bw, bin);
	split(skin, hsv);

	hsv[2] += bin[0] / 5;

	vector <Mat> channelsFinal;
	channelsFinal.push_back(hsv[0]);
	channelsFinal.push_back(hsv[1]);
	channelsFinal.push_back(hsv[2]);


	Mat finalImage;
	merge(channelsFinal, finalImage);
	hsv[2] -= 2 * (bin[0] / 5);


	vector<Mat> channelsDark;
	channelsDark.push_back(hsv[0]);
	channelsDark.push_back(hsv[1]);
	channelsDark.push_back(hsv[2]);
	Mat finalDark;
	merge(channelsDark, finalDark);

	cvtColor(finalDark, finalDark, CV_HSV2BGR);
	cvtColor(finalImage, finalImage, CV_HSV2BGR);
	imshow("fairer", finalImage);
	imshow("darker", finalDark);

	namedWindow("original");
	imshow("original", image);
	imshow("skin", bw);
	waitKey(0);
}


void question7b(Mat image) {
	Mat grey;
	cvtColor(image, grey, CV_BGR2GRAY);
	//imshow("GREY",grey);

	Mat tmp(grey.rows, grey.cols, CV_16SC1);
	Scalar mean, dev;
	meanStdDev(grey, mean, dev);

	for (int i = 0;i < grey.rows; i++) {
		for (int j = 0; j < grey.cols; j++) {
			//tmp.at<uchar>(i, j) = (grey.at<uchar>(i, j) - mean[0]) / dev[0];
		}
	}


	cout << mean << dev;
	//cout << grey;
	//imshow("lightGrey", grey);
	waitKey(0);
	system("pause");

}


void question8(Mat image) {

	//cvtColor(image, image, CV_BGR2GRAY);

	int DELAY_CAPTION = 1500;
	int DELAY_BLUR = 100;
	int MAX_KERNEL_LENGTH = 15;
	Mat gausBlur;
	gausBlur = image.clone();
	for (int i = 1; i < MAX_KERNEL_LENGTH; i += 2) {
		GaussianBlur(image, gausBlur, Size(i, i), 0, 0);
	}

	imshow("original", image);
	imshow("Gausian", gausBlur);
	waitKey(0);

}

void question9a(Mat image) {

	cvtColor(image, image, CV_BGR2GRAY);

	int MAX_KERNEL_LENGTH = 6;
	Mat noise;
	noise = image.clone();
	randn(noise, 20 , 10);
	noise = noise + image;
	Mat blur;
	blur = noise.clone();
	for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
		medianBlur(noise, blur, i);
		cout << "hello\n";
	}

	imshow("image", image);
	imshow("Gausian", noise);
	imshow("Median", blur);
	waitKey(0);
}

void question9b(Mat image) {
	cvtColor(image, image, CV_BGR2GRAY);
	Mat saltPepper = image.clone();
	randu(saltPepper, 0, 255);

	Mat black = saltPepper < 30;
	Mat white = saltPepper > 255;

	Mat saltPepperImg = image.clone();
	saltPepperImg.setTo(255, white);
	saltPepperImg.setTo(0, black);

	imshow("salt", saltPepperImg);


	int MAX_KERNEL_LENGTH = 10;
	Mat blur;
	blur = saltPepperImg.clone();
	for (int i = 1; i < MAX_KERNEL_LENGTH; i = i + 2) {
		medianBlur(saltPepperImg, blur, i);
		cout << "hello\n";
	}

	imshow("blurred", blur);
	waitKey(0);
}

void question14() {
	Mat image_bgr, image_gray, image_morph;
	Mat grad_x, abs_grad_x, image_gauss, image_close, image_otsu;
	vector<vector<Point> > contours;
	vector<Vec4i> hierarchy;
	int scale = 1;
	int delta = 0;
	int ddepth = CV_16S;
	image_bgr = imread("C:/Users/siddartha/Pictures/car11.jpg");

	if (!image_bgr.data)
	{
		printf("No image data \n");
		system("pause");
		return;
	}
	namedWindow("Display Image", WINDOW_NORMAL);
	imshow("Display Image", image_bgr);
	waitKey(0);
	cvtColor(image_bgr, image_gray, CV_BGR2GRAY);
	namedWindow("Display Image2", WINDOW_NORMAL);
	imshow("Display Image2", image_gray);
	waitKey(0);
	Sobel(image_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
	convertScaleAbs(grad_x, abs_grad_x);
	namedWindow("Display Image3", WINDOW_NORMAL);
	imshow("Display Image3", abs_grad_x);
	waitKey(0);
	GaussianBlur(abs_grad_x, image_gauss, Size(5, 5), 0, 0);
	namedWindow("Display Image4", WINDOW_NORMAL);
	imshow("Display Image4", image_gauss);
	waitKey(0);
	Mat element = getStructuringElement(MORPH_RECT, Size(23, 2), Point(-1, -1));
	morphologyEx(image_gauss, image_close, MORPH_CLOSE, element);
	namedWindow("Display Image5", WINDOW_NORMAL);
	imshow("Display Image5", image_close);
	waitKey(0);
	threshold(image_close, image_otsu, 0, 255, CV_THRESH_BINARY | CV_THRESH_OTSU);
	namedWindow("Display Image6", WINDOW_NORMAL);
	imshow("Display Image6", image_otsu);
	waitKey(0);
	findContours(image_otsu, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE, Point(0, 0));
	vector<vector<Point> >::iterator itc = contours.begin();
	Point2f vertices[4];
	Scalar color = Scalar(0, 0, 255);
	while (itc != contours.end())
	{
		RotatedRect mr = minAreaRect(Mat(*itc));
		float width = mr.size.width;
		float height = mr.size.height;
		bool output = false;
		if ((width != 0) & (height != 0))
		{
			if (((height / width>2) & (height>width)) | ((width / height>2) & (width>height)))
			{
				if ((height*width<10000) & (height*width>2000))
				{
					output = true;
					Point2f rect_points[4];
					mr.points(rect_points);
					for (int j = 0; j < 4; j++)
						line(image_bgr, rect_points[j], rect_points[(j + 1) % 4], color, 2, 8);
				}
			}
		}
		++itc;
	}
	namedWindow("Display Image7", WINDOW_NORMAL);
	imshow("Display Image7", image_bgr);
	waitKey(0);
	return;
}
void test() {
	Mat image = imread("C:/Users/siddartha/Pictures/car1.jpg");
	cvtColor(image, image, CV_BGR2GRAY);
	imshow("car", image);

	int morph_size = 2;
	Mat element = getStructuringElement(MORPH_RECT, Size(2 * morph_size + 1, 2 * morph_size + 1), Point(morph_size, morph_size));
	/*
	Mat dst;
	for (int i = 1;i < 10;i++)
	{

		morphologyEx(image, dst, MORPH_TOPHAT, element, Point(-1, -1), i, BORDER_CONSTANT);
		//morphologyEx( src, dst, MORPH_TOPHAT, element ); // here iteration=1
		imshow("source", image);
		imshow("result", dst);
		waitKey(1000);
	}
	*/

	Mat dil;
	dilate(image, dil, Mat(), Point(-1, -1), 2, 1, 1);
	imshow("dilation", dil);

	Mat ero;
	erode(dil, ero, Mat(), Point(-1, -1), 2, 1, 1);
	imshow("erode", ero);

	Mat sub;
	sub = image - ero;
	imshow("Subtraction", sub);

	waitKey(0);
}


void question10(Mat image) {
	Mat src, src_gray;
	Mat grad;
	char* window_name = "Sobel Demo - Simple Edge Detector";
	int scale = 1;
	int delta = 0;
	int ddepth = CV_16S;

	int c;

	/// Load an image
	src = image;

	if (!src.data)
	{
		return;
	}

	GaussianBlur(src, src, Size(3, 3), 0, 0, BORDER_DEFAULT);

	/// Convert it to gray
	cvtColor(src, src_gray, CV_BGR2GRAY);

	/// Create window
	namedWindow(window_name, CV_WINDOW_AUTOSIZE);

	/// Generate grad_x and grad_y
	Mat grad_x, grad_y;
	Mat abs_grad_x, abs_grad_y;

	/// Gradient X
	//Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
	Sobel(src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
	convertScaleAbs(grad_x, abs_grad_x);

	/// Gradient Y
	//Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
	Sobel(src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT);
	convertScaleAbs(grad_y, abs_grad_y);

	/// Total Gradient (approximate)
	addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);

	imshow(window_name, grad);

	waitKey(0);

}

int xGradient(Mat image, int x, int y)
{
	return image.at<uchar>(y - 1, x - 1) +
		 image.at<uchar>(y, x - 1) +
		image.at<uchar>(y + 1, x - 1) -
		image.at<uchar>(y - 1, x + 1) -
		 image.at<uchar>(y, x + 1) -
		image.at<uchar>(y + 1, x + 1);
}

// Computes the y component of the gradient vector
// at a given point in a image
// returns gradient in the y direction

int yGradient(Mat image, int x, int y)
{
	return image.at<uchar>(y - 1, x - 1) +
		image.at<uchar>(y - 1, x) +
		image.at<uchar>(y - 1, x + 1) -
		image.at<uchar>(y + 1, x - 1) -
		 image.at<uchar>(y + 1, x) -
		image.at<uchar>(y + 1, x + 1);
}

void prewitt(Mat image) {
	Mat src, dst;
	int gx, gy, sum;
	cvtColor(image, image, CV_BGR2GRAY);
	// Load an image
	src = image;
	dst = src.clone();
	if (!src.data)
	{
		return ;
	}


	for (int y = 0; y < src.rows; y++)
		for (int x = 0; x < src.cols; x++)
			dst.at<uchar>(y, x) = 0.0;

	for (int y = 1; y < src.rows - 1; y++) {
		for (int x = 1; x < src.cols - 1; x++) {
			gx = xGradient(src, x, y);
			gy = yGradient(src, x, y);
			sum = abs(gx) + abs(gy);
			sum = sum > 255 ? 255 : sum;
			sum = sum < 0 ? 0 : sum;
			dst.at<uchar>(y, x) = sum;
		}
	}

	namedWindow("final");
	imshow("final", dst);

	namedWindow("initial");
	imshow("initial", src);

	waitKey(0);

}

void question12(Mat image) {
	Mat src, src_gray, dst;
	int kernel_size = 3;
	int scale = 1;
	int delta = 0;
	int ddepth = CV_16S;
	char* window_name = "Laplace Demo";

	int c;

	/// Load an image
	src = image;

	if (!src.data)
	{
		return ;
	}

	/// Remove noise by blurring with a Gaussian filter
	//GaussianBlur(src, src, Size(3, 3), 0, 0, BORDER_DEFAULT);

	/// Convert the image to grayscale
	cvtColor(src, src_gray, CV_BGR2GRAY);

	/// Create window
	namedWindow(window_name, CV_WINDOW_AUTOSIZE);

	/// Apply Laplace function
	Mat abs_dst;

	Laplacian(src_gray, dst, ddepth, kernel_size, scale, delta, BORDER_DEFAULT);
	convertScaleAbs(dst, abs_dst);
	cout << image.channels();
	cout << "\t" << abs_dst.channels();
	/// Show what you got

	GaussianBlur(abs_dst, abs_dst, Size(3, 3), 0, 0, BORDER_DEFAULT);
	imshow(window_name, abs_dst);
	waitKey(0);


}

void main() {
	Mat image;
	image = imread("C:/Users/siddartha/Pictures/test2.jpg");
	if (image.empty()) {
		cout << "Cannot load image";
		system("pause");
		return;

	}
	else {
		cout << image.size();
		//namedWindow("original");
		//imshow("original", image);
		//question1(image);
		//question2(image);
		//question3(image);
		//question4(image);
		//question5();
		//question7a(image);
		//question7b(image);
		//question8(image);
		//question9a(image);
		//question9b(image);
		//question10(image);
		//prewitt(image);
		//question12(image);
		question14();
		//waitKey(0);
	}

}