#include <opencv2/opencv.hpp>
#include <windows.h>

using namespace std;
using namespace cv;

//zad.1
Mat image;
Point seed1, seed2;
int klik = 0;

//zad.2
Mat src1, src2;
const int alpha_slider_max = 100;
int alpha_slider;

//zad.4
vector<Point2f> Cel;


void negatyw(Mat& _src, Mat& _dst)	//progowanie dla zaznaczonego obszaru dla konkretnego kanalu
{
	_src.copyTo(_dst);
	typedef Vec<uchar, 3> Pixel;

	for (int i = seed1.y; i < seed2.y; i++)
		for (int j = seed1.x; j < seed2.x; j++)
		{
			_dst.at<Pixel>(i, j).val[0] = 255 - _dst.at<Pixel>(i, j).val[0];
			_dst.at<Pixel>(i, j).val[1] = 255 - _dst.at<Pixel>(i, j).val[1];
			_dst.at<Pixel>(i, j).val[2] = 255 - _dst.at<Pixel>(i, j).val[2];
		}
}

static void onMouse(int event, int x, int y, int, void*)
{
	if (event == EVENT_LBUTTONDOWN)
	{
		if (klik == 0)
		{
			seed1 = Point(x, y);
			klik = 1;
		}
		else if (klik == 1)
		{
			seed2 = Point(x, y);
			klik = 0;
			negatyw(image, image);	//operacja progowania dla kanłu zielonego
			imshow("org", image);
		}
	}
}


void NegativeDirectMemoryAccess(Mat& img)
{
	int kolumny = img.cols* alpha_slider / 100;;
	typedef Vec<uchar, 3> Pixel;
	for (int i = 0; i < img.rows; i++)
		for (int j = 0; j < kolumny; j++)
		{
			img.at<Pixel>(i, j).val[0] = 255 - img.at<Pixel>(i, j).val[0];
			img.at<Pixel>(i, j).val[1] = 255 - img.at<Pixel>(i, j).val[1];
			img.at<Pixel>(i, j).val[2] = 255 - img.at<Pixel>(i, j).val[2];
		}

}

void pomaluj(Mat& _src, Mat& _dst)
{
	_src.copyTo(_dst);
	typedef Vec<uchar, 3> Pixel;
	int liczba =_src.at<Pixel>(160, 110).val[1];
	cout << liczba << endl;

	for (int i = 0; i < _dst.rows; i++)
		for (int j = 0; j < _dst.cols; j++)
		{
			if (_dst.at<Pixel>(i, j).val[0] == 169)
			{
				_dst.at<Pixel>(i, j).val[0] = 39;
				_dst.at<Pixel>(i, j).val[1] = 127;
				_dst.at<Pixel>(i, j).val[2] = 255;
			}
		}

}

void on_trackbar(int, void*)
{
	src2 = src1.clone();
	NegativeDirectMemoryAccess(src2);
	namedWindow("mod");
	imshow("mod", src2);
}

static void onMouse2(int event, int x, int y, int, void*)
{
	if (event == EVENT_RBUTTONDOWN)
	{
		cout << "[" << x << "," << y << "]" << endl;
	}
	if (event == EVENT_LBUTTONDOWN)
	{
		Point temp1;
		temp1 = Point(x, y);
		Cel.push_back(temp1);
		klik++;

	}
}
void telewizor()
{

	vector <Point2f> narozniki4;
	Mat lambda(2, 4, CV_32FC1);
	Mat output;
	Mat tlo, tv;
	Point2f temporary;
	tlo = imread("tv.png", CV_LOAD_IMAGE_COLOR);
	imshow("tlo", tlo);
	setMouseCallback("tlo", onMouse2, 0);


	temporary.x = 0;
	temporary.y = 0;
	narozniki4.push_back(temporary);
	temporary.x = 640;
	temporary.y = 0;
	narozniki4.push_back(temporary);
	temporary.x = 640;
	temporary.y = 480;
	narozniki4.push_back(temporary);
	temporary.x = 0;
	temporary.y = 480;
	narozniki4.push_back(temporary);
	cout << "Narozniki :\n" << narozniki4 << endl;

	VideoCapture cap(0); // open the default camera

	while (1)
	{
		cap >> tv; // get a new frame from camera
		imshow("camera", tv);


		int numberOfChannels = tv.channels();
		int numberOfPixels = tv.rows * tv.cols * numberOfChannels;
		uchar* p = tv.data;
		for (int i = 0; i < numberOfPixels; i = i + numberOfChannels)
			for (int j = 0; j < numberOfChannels; ++j)
				if (p[i + j] == 0)	p[i + j] = 1;

		if (klik >= 4)
		{
			lambda = Mat::zeros(tv.rows, tv.cols, tv.type());	//rozmiar taki jaki obraz wycinamy
			lambda = getPerspectiveTransform(narozniki4, Cel);	//(rozmiar jaki chcemy wyciac, rozmiar jaki chcemy uzyskac)
			warpPerspective(tv, output, lambda, Size(tlo.cols, tlo.rows));	//rozmiar obrazu wyjscowego

			int numberOfChannels = output.channels();
			int numberOfPixels = output.rows * output.cols * numberOfChannels;
			uchar* p = output.data;
			uchar* wyjscie = tlo.data;
			for (int i = 0; i < numberOfPixels; i = i + numberOfChannels)
			{
				for (int j = 0; j < numberOfChannels; ++j)
				{
					if (p[i + j] != 0)	wyjscie[i + j] = p[i + j];
				}
			}
			imshow("wynik", tlo);
		}


		if (waitKey(1) >= 0)	waitKey(0);
	}
}

int main(int argc, char** argv)
{
	//zad.1
	/*image = imread("zad_1.jpg");
	if (!image.data) { printf("Error loading src1 \n"); return -1; }
	imshow("org", image);
	setMouseCallback("org", onMouse, 0);*/

	//zad2
	/*src1 = imread("zad_1.jpg", CV_LOAD_IMAGE_COLOR);
	if (!src1.data) { printf("Error loading src1 \n"); return -1; }
	char TrackbarName[50];
	imshow("org", src1);
	sprintf_s(TrackbarName, "Alpha x %d", alpha_slider_max);
	createTrackbar(TrackbarName, "org", &alpha_slider, alpha_slider_max, on_trackbar);
	on_trackbar(alpha_slider, 0);*/

	//zad.3
	/*Mat src3, src4, obraz_filter, obraz_diff;
	Mat M = (Mat_ <int>(3, 3) << 0, -1, 0, -1, 4, -1, 0, -1, 0);
	src3 = imread("zad_3.png",IMREAD_GRAYSCALE);
	imshow("org", src3);
	cout << M << endl;
	filter2D(src3, obraz_filter, -1, M);
	obraz_diff = abs(obraz_filter);
	obraz_diff.convertTo(src4, CV_8U);
	imshow("mod", src4);*/

	//zad.4
	telewizor();

	//zad.7
	/*Mat src5, src6;
	src5 = imread("lew.png", CV_LOAD_IMAGE_COLOR);
	imshow("org", src5);
	pomaluj(src5, src6);	//operacja progowania dla kanłu zielonego
	imshow("org", src6);*/


	waitKey(0);

}