#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <vector>
#include <opencv2/opencv.hpp>

using namespace cv;
using namespace std;

bool between(int beker, int alsohatar, int felsohatar) {
	return alsohatar <= beker && beker <= felsohatar;
}

void printType(Mat& img) {
	int depth = img.depth();

	switch (depth) {
	case 0: 
		cout << "CV_8U:" << img.channels() << endl;
		break;
	case 1: 
		cout << "CV_8S:" << img.channels() << endl;
		break;
	case 2: 
		cout << "CV_16U:" << img.channels() << endl;
		break;
	case 3: 
		cout << "CV_16S:" << img.channels() << endl;
		break;
	case 4: 
		cout << "CV_32S:" << img.channels() << endl;
		break;
	case 5: 
		cout << "CV_32F:" << img.channels() << endl;
		break;
	case 6:
		cout << "CV_64F:" << img.channels() << endl;
		break;
	default:
		cout << "Unknown" << endl;
		break;
 	}

}

void printImageType(Mat& img) {
	int channel = img.channels();
	int depth = img.depth();

	if (depth == 0 && channel == 1) {
		cout << "8 bites szurkearnayalatos" << endl;
	}
	else if (depth == 0 && channel == 3) {
		cout << "24 bites RGB kep" << endl;
	}
	else {
		cout << "Ismeretlen kepformatum" << endl;
	}


}

void eloterMasol(const Mat fg, Mat& bg) {
	for (int i = 0; i < fg.rows; i++) {
		for (int j = 0; j < fg.cols; j++) {
			Vec3b bgr = fg.at<Vec3b>(i, j);
			if (!(bgr[0] > 230 && bgr[1] > 230 && bgr[2] > 230)) {
				bg.at<Vec3b>(i, j) = bgr;
			}
		}
	}
}

void eloterMasolEsEltol(const Mat fg, Mat& bg, int offsetX, float offsetY) {
	for (int i = 0; i < fg.rows; i++) {
		for (int j = 0; j < fg.cols; j++) {
			Vec3b bgr = fg.at<Vec3b>(i, j);
			if (!(bgr[0] > 230 && bgr[1] > 230 && bgr[2] > 230)) {

				int bgRow = i + offsetY;
				int bgCols = j + offsetX;
				if (bgRow > 0 && bgRow < bgCols && bgCols > 0 && bgCols < bg.cols) {
					bg.at<Vec3b>(bgRow, bgCols) = bgr;
				}

			}
		}
	}
}

void narancsMasolo(const Mat src, Mat& dest) {
	for (int row = 0; row < src.rows; row++) {
		for (int col = 0; col < src.cols; col++) {
			Vec3b pix = src.at<Vec3b>(row, col);
			if (pix[0] < 80 && pix[1] < 190 && pix[2] < 255) {
				dest.at<Vec3b>(row, col) = pix;
			}
		}
	}
}

void narancsMasoloHSV(const Mat src, Mat& dest) {
	Mat kaksi;
	cvtColor(src, kaksi, COLOR_BGR2HSV);
	for (int row = 0; row < kaksi.rows; row++) {
		for (int col = 0; col < kaksi.cols; col++) {
			Vec3b pix = src.at<Vec3b>(row, col);
			if (between(pix[0], 0, 55)) {
				dest.at<Vec3b>(row, col) = pix;
			}
		}
	}
}

void narancsMasoloHSV2(const cv::Mat rgb, cv::Mat& dest) {

	Mat hsv;
	cvtColor(rgb, hsv, ColorConversionCodes::COLOR_BGR2HSV);
	// a narancs szinu pontok "kijelolese"  
	Mat mask;
	inRange(hsv, Scalar(0, 0, 0), Scalar(30, 255, 255), mask);
	// a maszk feher resze ala eso keppontok masolasa az eredeti rgb keprol az eredmeny kepre
	rgb.copyTo(dest, mask);
}

void lilamasolo(const Mat& img, Mat& dest) {
	Mat hsv;
	cvtColor(img, hsv, COLOR_BGR2HSV);

	Mat mask;
	inRange(hsv, Scalar(120, 50, 50), Scalar(150, 255, 255), mask);

	img.copyTo(dest);

	Mat temp;
	dest.copyTo(temp);

	for (int row = 0; row < img.rows; row++) {
		for (int col = 0; col < img.cols; col++) {
			if (mask.at<uchar>(row, col) > 0) { 
				Vec3b& pixel = temp.at<Vec3b>(row, col);
				pixel[0] = 30; 
			}
		}
	}

	temp.copyTo(dest);
}

void convertToLab(Mat& img, const Mat dest) {
	Mat dest_float;
	cvtColor(img, dest_float, COLOR_BGR2Lab, 1/255.0);
	dest_float.convertTo(dest, CV_32FC3);
}

void createHisto(const Mat img, Mat& hiszto) {
	vector<Mat> kepek;
	kepek.push_back(img); 
	vector<int> csatornak;
	csatornak.push_back(0); 
	vector<int> hiszto_meretek;
	hiszto_meretek.push_back(256); 
	vector<float> hiszto_tartomanyok;
	hiszto_tartomanyok.push_back(0.0f);
	hiszto_tartomanyok.push_back(255.f); 
	calcHist(kepek, csatornak, noArray(), hiszto, hiszto_meretek, hiszto_tartomanyok, false);
}

int main() {
	//Mat img = imread("D:/fontosak/info/kepfeldolgozas/kepek/mormota_kekhatter.jpg");
	//imshow("img", img);

//Alapveto informaciok lekerdezese
/*
	// sorok es oszlopok szama
	cout << img.rows << " " << img.cols << endl;

	// kep tipusa
	printType(img);

	//milyen tipusu keprol van szo
	printImageType(img);
*/

//Keszitsd el:
/*
	//szurkeskalas kep, 200 sor 50 oszlop
	Mat egy;
	egy.create(200, 50, CV_8UC1);
	imshow("egy", egy);

	//szines kep, 50 sor 200 oszlop
	Mat ketto;
	ketto.create(50, 200, CV_8UC3);
	imshow("ketto", ketto);

	//fekete kep, 20 sor 40 oszlop
	Mat harom = Mat::zeros(20, 40, CV_8UC1);
	imshow("harom", harom);

	//feher kep, 20 sor 40 oszlop
	Mat negy;
	negy.create(20, 40, CV_8UC1);
	negy.setTo(Scalar(255));
	imshow("negy", negy);

	//szines kep, 99 sor 121 oszlop
	Mat ot;
	ot.create(20, 40, CV_8UC3);
	ot.setTo(Scalar(0,0,255));
	imshow("ot", ot);


	//olvass be egy kepet es keszits egy masikat azonos merettel es tipussal
	Mat hat;
	hat.create(img.size(), img.type());
	hat.setTo(Scalar(255));
	imshow("hat",hat);

	//olvass be egy kepet es keszits egy masikat azonos szelessegel es tipussal de a magassaga a fele
	Mat het;
	het.create(img.rows/2, img.cols, img.type());
	het.setTo(Scalar(255));
	imshow("het", het);
*/

//Sekely vs mely
/*
	//Keszits sekely masolatot, setTo-val szinezd at, jelenitsd meg mindkettot
	Mat egy;
	egy = img;
	egy.setTo(Scalar(255, 130, 45));
	imshow("egy", egy);
	//imshow("img", img); -sekely masolatnal ugyanigy valtoztatja az eredeti kepet mint a masolatot

	//Keszits mely masolatot, setTo-val szinezd at, jelenitsd meg mindkettot
	Mat ketto;
	ketto = img.clone();
	ketto.setTo(255);
	imshow("ketto", ketto);
*/

//Kurama szetszedese
/*
	Mat img = imread("D:/fontosak/info/kepfeldolgozas/kepek/kurama.jpg",IMREAD_COLOR);
	imshow("img", img);
	vector<Mat> channels;
	split(img, channels);
	imshow("kek", channels[0]);
	imshow("green", channels[1]);
	imshow("red", channels[2]);
	*/

//Nem feher pontok masolasa
/*
	Mat hatter = imread("D:/fontosak/info/kepfeldolgozas/kepek/background.jpg");
	imshow("hatter", hatter);
	Mat hattermasolo = hatter.clone();
	resize(hattermasolo, hattermasolo, img.size());
	eloterMasol(img, hattermasolo);
	imshow("merged", hattermasolo);
*/

//Nem feher pontok masolasa -- hazi (nem ment teljesen)
/*
	Mat kurama = imread("D:/fontosak/info/kepfeldolgozas/kepek/kurama.jpg", IMREAD_COLOR);
	Mat hatter = imread("D:/fontosak/info/kepfeldolgozas/kepek/background.jpg", IMREAD_COLOR);
	resize(kurama, kurama, Size(kurama.cols / 4, kurama.rows / 4));
	imshow("kurama", kurama);
	imshow("hatter", hatter);
	Mat mask;
	inRange(kurama, Scalar(200, 200, 200), Scalar(255, 255, 255), mask);
	mask = 255 - mask;
	imshow("mask", mask);
	int x = (hatter.cols - kurama.cols) / 2;
	int y = hatter.rows - kurama.rows;
	for (int i = 0; i < kurama.rows; i++) {
		for (int j = 0; j < kurama.cols; j++) {
			if (mask.at<uchar>(i, j) == 255) {
				if (i + y >= 0 && i + y < hatter.rows && j + x >= 0 && j + x < hatter.cols) {
					hatter.at<Vec3b>(i + y, j + x) = kurama.at<Vec3b>(i, j);
				}
			}
		}
	}
	imshow("hatter", hatter);
*/

//narancsmasolo (RGB)
/*
	Mat dest;
	dest.create(img.size(), img.type());
	narancsMasolo(img, dest);
	imshow("dest", dest);
*/

//narancsmasolo (HSV)
/*
	Mat dest;
	dest.create(img.size(), img.type());
	narancsMasoloHSV(img, dest);
	imshow("dest", dest);
*/

//milkamasolo (HSV)
/*
	Mat img = imread("D:/fontosak/info/kepfeldolgozas/kepek/milka.jpg", IMREAD_COLOR);
	Mat dest;
	dest.create(img.size(), img.type());
	lilamasolo(img, dest);
	imshow("dest", dest);
*/

//mormotakivagas
/*
	Mat hsv;
	cvtColor(img, hsv, COLOR_BGR2HSV);
	imshow("hsv", hsv);
	Mat mask;
	inRange(hsv, Scalar(100, 0, 0), Scalar(130, 255, 255), mask);
	mask = 255 - mask;
	imshow("mask",mask);
	Mat hatter = imread("D:/fontosak/info/kepfeldolgozas/kepek/Deik.jpg");
	Rect teglalap(0, ((hatter.rows - 1) - img.rows), img.cols, img.rows);
	Mat deiktaglalap = hatter(teglalap);
	for (int row = 0; row < deiktaglalap.rows; row++) {
		for (int col = 0; col < deiktaglalap.cols; col++) {
			if (mask.at<uchar>(row, col) > 0) {
				deiktaglalap.at<Vec3b>(row, col) = img.at<Vec3b>(row, col);
			}
		}
	}
	imshow("kaki", deiktaglalap);
	Mat dest = hatter.clone();
	deiktaglalap.copyTo(dest(teglalap));
	imshow("dest", dest);
*/

//szinkulonbseg (nem fejeztem be)
/*
	Mat dest;
	convertToLab(img,dest);
	imshow("dest", dest);
	printType(dest);
	printImageType(dest);
	/*
	Vec3f bal_felso = dest_float.at<Vec3f>(0, 0);
	Vec3f jobb_felso = dest_float.at<Vec3f>(0, dest_float.cols-1);
	Vec3f random1 = dest_float.at<Vec3f>(32, 3);
	Vec3f random2 = dest_float.at<Vec3f>(32, 4);
	cout << bal_felso[0] << " " << bal_felso[1] << " " << bal_felso[2] << endl;
	cout << jobb_felso[0] << " " << jobb_felso[1] << " " << jobb_felso[2] << endl;
	cout << random1[0] << " " << random1[1] << " " << random1[2] << endl;
	cout << random2[0] << " " << random2[1] << " " << random2[2] << endl;
	*/
	
//ppt gyakorl -1
	//1.
	/*
	Mat zoldalma = imread("D:/fontosak/info/kepfeldolgozas/kepek/zold_alma.jpg", IMREAD_COLOR);
	imshow("alma", zoldalma);
	Mat masolni = Mat::zeros(zoldalma.rows,zoldalma.cols,CV_8UC3);
	for (int row = 0; row < masolni.rows; ++row) {
		for (int col = 0; col < masolni.cols; ++col) {
			Vec3b ertek = zoldalma.at<Vec3b>(row, col);
			if (ertek[1] > ertek[0] && ertek[1] > ertek[2]) {
				masolni.at<Vec3b>(row, col) = ertek;
			}
		}
	}
	imshow("masolni", masolni);
	*/
	
	//2
	/*
	Mat alma = imread("D:/fontosak/info/kepfeldolgozas/kepek/piros_alma_sziv.jpg", IMREAD_COLOR);
	imshow("alma", alma);
	Mat masolni = Mat::zeros(alma.rows, alma.cols, CV_8UC3);
	imshow("kaki", masolni);
	for (int row = 0; row < alma.rows; row++) {
		for (int col = 0; col < alma.cols; col++) {
			Vec3b pixel = alma.at<Vec3b>(row, col);
			if (pixel[0] < 180 && pixel[1] < 190 && pixel[2] < 255) {
				masolni.at<Vec3b>(row, col) = pixel;
			}
		}
	}
	imshow("masolni", masolni);
	*/

	//3
	/*
	Mat dekoracio = imread("D:/fontosak/info/kepfeldolgozas/kepek/dekoracio.png",IMREAD_COLOR);
	Mat hatter = imread("D:/fontosak/info/kepfeldolgozas/kepek/background2.jpg",IMREAD_COLOR);
	for (int row = 0; row < hatter.rows; ++row) {
		for (int col = 0; col < hatter.cols; ++col) {
			if (col < dekoracio.cols && row < dekoracio.rows) {
				Vec3b pixel = dekoracio.at<Vec3b>(row, col);
				hatter.at<Vec3b>(row + 200, col + 150) = pixel;
				hatter.at<Vec3b>(row + 30, col + 200) = pixel;
			}
		}
	}
	imshow("hatter", hatter);
	*/

	//4
	/*
	Mat mm  = imread("D:/fontosak/info/kepfeldolgozas/kepek/mm2.png", IMREAD_COLOR);
	Mat dest = Mat::zeros(mm.rows,mm.cols, CV_8UC3);
	for (int row = 0; row < mm.rows; ++row) {
		for (int col = 0; col < mm.cols; ++col) {
			Vec3b pixel = mm.at<Vec3b>(row, col);
			if (pixel[2] > pixel[1] && pixel[2] > pixel[0]) {
				dest.at<Vec3b>(row, col) = pixel;
			}
		}
	}
	imshow("dest",dest);
	*/

	//5
	/*
	Mat mm = imread("D:/fontosak/info/kepfeldolgozas/kepek/mm2.png", IMREAD_COLOR);
	Mat dest = Mat::zeros(mm.rows, mm.cols, CV_8UC3);
	Mat hsv;
	cvtColor(mm,hsv,COLOR_BGR2HSV);
	for (int row = 0; row < mm.rows; ++row) {
		for (int col = 0; col < mm.cols; ++col) {
			Vec3b pixel = hsv.at<Vec3b>(row, col);
			if (pixel[0] > 100 && pixel[0] < 130) {
				dest.at<Vec3b>(row, col) = mm.at<Vec3b>(row, col);
			}
		}
	}
	imshow("dest", dest);
	*/

	//6
	/*
	Mat mm = imread("D:/fontosak/info/kepfeldolgozas/kepek/mm2.png", IMREAD_COLOR);
	imshow("mm", mm);
	Mat dest = Mat::zeros(mm.rows, mm.cols, CV_8UC3);
	Mat hsv;
	cvtColor(mm, hsv, COLOR_BGR2HSV);
	for (int i = 0; i < mm.rows; ++i) {
		for (int j = 0; j < mm.cols; ++j) {
			Vec3b pixel = hsv.at<Vec3b>(i, j);
			if (pixel[0] >= 90 && pixel[0] <= 130) {
				dest.at<Vec3b>(i, j)[1] = 120;
			}
		}
	}
	imshow("dest", dest);
	*/

	//7
	/*
	Mat dekor = imread("D:/fontosak/info/kepfeldolgozas/kepek/dekoracio.png", IMREAD_COLOR);
	imshow("mm", dekor);
	Mat dest = Mat::zeros(dekor.rows, dekor.cols, CV_8UC3);
	Mat hsv;
	cvtColor(dekor, hsv, COLOR_BGR2HSV);
	for (int i = 0; i < dekor.rows; ++i) {
		for (int j = 0; j < dekor.cols; ++j) {
			Vec3b pixel = hsv.at<Vec3b>(i, j);
			if (pixel[0] >= 5 && pixel[0] <= 25) {
				dest.at<Vec3b>(i, j) = dekor.at<Vec3b>(i, j);
			}
		}
	}
	imshow("dest", dest);
	*/

	//8
	/*
	Mat szolo = imread("D:/fontosak/info/kepfeldolgozas/kepek/szolo.png", IMREAD_COLOR);
	imshow("eredeti", szolo);
	resize(szolo, szolo, Size(szolo.rows/5,szolo.cols/5));
	imshow("mm", szolo);
	Mat dest = Mat::zeros(szolo.rows, szolo.cols, CV_8UC3);
	Mat hsv;
	cvtColor(szolo, hsv, COLOR_BGR2HSV);
	for (int i = 0; i < szolo.rows; ++i) {
		for (int j = 0; j < szolo.cols; ++j) {
			Vec3b pixel = szolo.at<Vec3b>(i, j);
			if (pixel[0] <= 110) {
				dest.at<Vec3b>(i, j) = szolo.at<Vec3b>(i, j)[2];
			}
		}
	}
	imshow("dest", dest);
	*/

	//9
	/*
	Mat szolo = imread("D:/fontosak/info/kepfeldolgozas/kepek/szolo.png", IMREAD_COLOR);
	Mat szoloLab;
	cvtColor(szolo, szoloLab, COLOR_BGR2Lab);
	//fogalmam sincs innentol kezdve mi lenne a feladat tbh
	imshow("szolo", szolo);
	imshow("Lab", szoloLab);
	*/

//ppt gyakorlo -2
	//1.
	/*
	Mat pillango = imread("D:/fontosak/info/kepfeldolgozas/kepek/img1.jpg", IMREAD_COLOR);
	Mat dest;
	cvtColor(pillango, dest, COLOR_BGR2GRAY);
	imshow("eredeti", pillango);
	imshow("dest", dest);
	*/

	//2
	
	//2
	/*
	Mat sakura = imread("D:/fontosak/info/kepfeldolgozas/kepek/img2.jpg", IMREAD_COLOR);
	imshow("kaksi", sakura);
	vector<Mat> chs;
	split(sakura, chs);
	chs[2] = 255 - chs[2];
	imshow("piros", chs[2]);
	merge(chs, sakura);
	imshow("kep", sakura);
	*/

	//3 (nem irok erre egy fuggvenyt fix)
	/*
	Mat sziv = imread("D:/fontosak/info/kepfeldolgozas/kepek/img3.jpg", IMREAD_COLOR);
	resize(sziv, sziv, Size(sziv.cols / 3, sziv.rows / 3));
	Mat hatter = Mat::zeros(Size(sziv.cols, sziv.rows), CV_8UC3);
	Mat mask;
	inRange(sziv, Scalar(0, 0, 0), Scalar(0, 0, 255), mask);
	for (int i = 0; i < sziv.rows; ++i) {
		for (int j = 0; j < sziv.cols; ++j) {
			Vec3b pixel = sziv.at<Vec3b>(i, j);
			if (mask.at<uchar>(i, j) > 0) {
				hatter.at<Vec3b>(i, j) = pixel;
			}
		}
	}
	imshow("hatter", hatter);
	*/
	
	//4
	/*
	Mat almak = imread("D:/fontosak/info/kepfeldolgozas/kepek/img4.jpg", IMREAD_COLOR);
	imshow("alma", almak);
	Mat hatter = Mat::zeros(Size(almak.cols, almak.rows), CV_8UC3);
	hatter.setTo(Scalar(255, 255, 255));
	imshow("hatter", hatter);
	for (int i = 0; i < almak.rows; ++i) {
		for (int j = 0; j < almak.cols; ++j) {
			Vec3b pixel = almak.at<Vec3b>(i, j); 
			if (pixel[1] > pixel[0] && pixel[1] > pixel[2]) {
				hatter.at<Vec3b>(i, j) = pixel;
			}
			
		}
	}
	imshow("almas", hatter);
	*/

	//5
	/*
	Mat spar = imread("D:/fontosak/info/kepfeldolgozas/kepek/img5.jpg", IMREAD_COLOR);
	Mat original = spar.clone();
	for (int i = 0; i < spar.rows; ++i) {
		for (int j = 0; j < spar.cols; ++j) {
			Vec3b pixel = spar.at<Vec3b>(i, j);
			if (pixel[2] < 200) {
				original.at<Vec3b>(i, j) = pixel[1];
			}
		
		}
	}
	imshow("og", original);
	*/

	//6
	/*
	Mat lufi = imread("D:/fontosak/info/kepfeldolgozas/kepek/img6.jpg", IMREAD_COLOR);
	Mat hatter = lufi.clone();
	hatter.setTo(Scalar(255, 255, 255));
	imshow("kep", hatter);
	Mat hsv;
	cvtColor(lufi, hsv, COLOR_BGR2HSV);;
	imshow("hsv", hsv);
	Mat mask;
	inRange(hsv, Scalar(130, 0, 0), Scalar(170, 255, 255), mask);
	imshow("mask", mask);
	for (int i = 0; i < lufi.rows; ++i) {
		for (int j = 0; j < lufi.cols; ++j) {
			if ((mask.at<uchar>(i, j) > 0)) {
				hatter.at<Vec3b>(i, j) = lufi.at<Vec3b>(i, j);
			}
		}
	}
	imshow("hatter",hatter);
	*/

	//7
	/*
	Mat szivarvany = imread("D:/fontosak/info/kepfeldolgozas/kepek/img7.jpg", IMREAD_COLOR);
	Mat hatter = szivarvany.clone();
	Mat hsv, mask;
	cvtColor(szivarvany, hsv, COLOR_BGR2HSV);
	inRange(hsv, Scalar(160, 0, 0), Scalar(179, 255, 255), mask);
	for (int i = 0; i < szivarvany.rows; ++i) {
		for (int j = 0; j < szivarvany.cols; ++j) {
			if (mask.at<uchar>(i,j) > 0) {
				hatter.at<Vec3b>(i,j) = szivarvany.at<Vec3b>(i, j)[2];	
			}
		}
	}
	imshow("szivarvany", hatter);
	*/

	//8
	/*
	Mat stitch = imread("D:/fontosak/info/kepfeldolgozas/kepek/img8_2.jpg", IMREAD_COLOR);
	resize(stitch, stitch, Size(500, 500));
	imread("alap", stitch);
	Mat hatter = imread("D:/fontosak/info/kepfeldolgozas/kepek/img8_1.jpg", IMREAD_COLOR);
	imread("kaksifej", hatter);
	Mat mask, hsv;
	cvtColor(stitch, hsv, COLOR_BGR2HSV);
	inRange(hsv, Scalar(0, 0, 0), Scalar(255, 255, 80), mask);
	imshow("mask", mask);
	for (int i = 0; i < stitch.rows; ++i) {
		for (int j = 0; j < stitch.cols; ++j) {
			if (mask.at<uchar>(i, j) > 0) {
				hatter.at<Vec3b>(i, j) = stitch.at<Vec3b>(i, j);
			}
		}
	}
	imshow("hatter",hatter);
	*/

	//9
	//kulonbseg szamitasahoz
	/*
	Mat horse = imread("D:/fontosak/info/kepfeldolgozas/kepek/img9.jpg", IMREAD_COLOR);
	imshow("lo", horse);
	Mat horseLab;
	horse.convertTo(horseLab, CV_32FC3, 1/255.0);
	cvtColor(horseLab, horseLab, COLOR_BGR2Lab);
	Vec3f p1 = horseLab.at<Vec3f>(0, 0);
	Vec3f p2 = horseLab.at<Vec3f>(horseLab.rows / 2, horseLab.cols / 2);
	double ertek = norm(p1 - p2);
	cout << ertek << endl;
	*/
	//lo megjelenitesehez
	/* 
	Mat horse = imread("D:/fontosak/info/kepfeldolgozas/kepek/img9.jpg", IMREAD_COLOR);
	imshow("lo", horse);
	Mat horseLab;
	cvtColor(horse, horseLab, COLOR_BGR2Lab);
	imshow("horse", horseLab);
	*/


//Hisztogram nyujtas
	//for ciklussal
	/*
	Mat debrecen_deep = imread("D:/fontosak/info/kepfeldolgozas/kepek/debrecen_deep.png", IMREAD_GRAYSCALE);
	double min, max;
	cv::minMaxLoc(debrecen_deep, &min, &max);
	Mat dest = debrecen_deep.clone();
	for (int i = 0; i < debrecen_deep.rows; ++i) {
		for (int j = 0; j < debrecen_deep.cols; ++j) {
			uchar pixel = debrecen_deep.at<uchar>(i, j);
			dest.at<uchar>(i, j) = (pixel - min) * (255 / (max - min));
		}
	}
	imshow("dest",dest);
	cout << min << " " << max << endl;
	*/

	//beepitett fuggvennyel
	/*
	Mat debrecen_deep = imread("D:/fontosak/info/kepfeldolgozas/kepek/debrecen_deep.png", IMREAD_GRAYSCALE);
	Mat dest = debrecen_deep.clone();
	equalizeHist(debrecen_deep, dest);
	imshow("eredeti", debrecen_deep);
	imshow("dest", dest);
	*/

	//beepitett szinesre
		//BGR
		/*
		Mat narancs = imread("D:/fontosak/info/kepfeldolgozas/kepek/orange1.jpg");
		imshow("bnarancs", narancs);
		vector<Mat> chs;
		Mat dest;
		split(narancs, chs);
		for (int i = 0; i < chs.size(); i++) {
			equalizeHist(chs[i], chs[i]);
		}
		merge(chs,dest);
		imshow("dest", dest);
		*/

		//HSV
		/*
		Mat narancs = imread("D:/fontosak/info/kepfeldolgozas/kepek/orange1.jpg",IMREAD_COLOR);
		imshow("narancs", narancs);
		cvtColor(narancs, narancs, COLOR_BGR2HSV);
		vector<Mat> chs;
		split(narancs, chs);
		equalizeHist(chs[2], chs[2]);
		Mat dest;
		merge(chs, dest);
		cvtColor(dest, dest, COLOR_HSV2BGR);
		imshow("dest", dest);
		*/


//Zajszures
	//blur (sima, gauss, median, billat)
	/*
	Mat szita = imread("D:/fontosak/info/kepfeldolgozas/kepek/szita.png",IMREAD_GRAYSCALE);
	imshow("kep", szita);
	string menu = "tool";
	namedWindow(menu, WINDOW_NORMAL);
	resizeWindow(menu, Size(500, 500));
	int radius = 1, sigma = 1;
	createTrackbar("radius", menu, &radius, 25);
	createTrackbar("sigma", menu, &sigma, 25);
	Mat blur_img, gauss_img, median_img, billat_img;
	while (waitKey(20) != 'q') {
		blur(szita, blur_img, Size(2 * radius + 3, 2 * radius + 3));
		GaussianBlur(szita, gauss_img, Size(2 * radius + 3, 2 * radius + 3), sigma);
		medianBlur(szita, median_img, 2*radius+3);
		bilateralFilter(szita, billat_img, 5, sigma * 10, 2 * radius + 3);
		imshow("blur", blur_img);
		imshow("gauss", gauss_img);
		imshow("median", median_img);
		imshow("billat", billat_img);

	}
	*/

	//Kossuth ter
	/*
	Mat alap = imread("D:/fontosak/info/kepfeldolgozas/kepek/KossuthSquare/SnapShot-20180731_173715.jpg", IMREAD_COLOR);
	Mat hatter = Mat::zeros(Size(alap.cols,alap.rows), CV_64FC3);
	int s = 0;
	
	for (int szamlalo = 715; szamlalo <= 918; szamlalo++) {
		Mat current = imread("D:/fontosak/info/kepfeldolgozas/kepek/KossuthSquare/SnapShot-20180731_173" + to_string(szamlalo) + ".jpg", IMREAD_COLOR);
		if (!current.empty()) {
			s++;
			Mat currentatvaltva;
			current.convertTo(currentatvaltva, CV_64FC3);
			accumulate(currentatvaltva, hatter);
			imshow("jelenlegi", current);
			waitKey(1);
		}
	}
	Mat dest;
	hatter.convertTo(dest, CV_8UC3, 1.0 / s);
	imshow("eredmeny", dest);
	*/


//Kuszoboles
	/*
	Mat aut, man, blur;
	int radius = 1;
	Mat dog = imread("D:/fontosak/info/kepfeldolgozas/kepek/dog.jpg", IMREAD_GRAYSCALE);
	imshow("kutyuly", dog);
	threshold(dog, man, 100, 200, THRESH_BINARY);
	imshow("kutyuly2", man);
	threshold(dog, aut, 100 ,255, THRESH_OTSU);
	imshow("kutyuly3", aut);
	medianBlur(aut, blur, 2*radius+3);
	imshow("kutyuly4", blur);
	*/


//Vagas
	//kutja
	/*
	Mat dog = imread("D:/fontosak/info/kepfeldolgozas/kepek/dog.jpg", IMREAD_GRAYSCALE);
	Mat dest;
	threshold(dog, dest, 100, 255, THRESH_TOZERO);
	imshow("dog", dog);
	Mat s = getStructuringElement(MORPH_ELLIPSE, Size(3, 3));
	morphologyEx(dest, dest, MORPH_OPEN, s);
	imshow("eredmeny", dest);
	*/
	
	
	//madar
	/*
	Mat madar = imread("D:/fontosak/info/kepfeldolgozas/kepek/madar.jpg", IMREAD_COLOR);
	Mat hatter = Mat::zeros(madar.size(), CV_8UC3);
	vector<Mat> chs;
	split(madar, chs);
	Mat mask;
	threshold(chs[0], mask, 140, 255, THRESH_TOZERO);
	imshow("kek", chs[0]);
	madar.copyTo(hatter, mask);
	imshow("hatter", hatter);
	*/


//Savkivagas 
	/*
	Mat gomb = imread("D:/fontosak/info/kepfeldolgozas/kepek/gray_buttons.jpg", IMREAD_GRAYSCALE);
	imshow("eredet", gomb);
	Mat mask,dest;
	inRange(gomb, Scalar(165), Scalar(213), mask);
	imshow("mask", mask);
	medianBlur(mask, mask, 5);
	imshow("dest", mask);
	mask = 255 - mask;
	imshow("mask2", mask);
	bitwise_and(gomb, mask, dest);
	imshow("eredmeny", dest);
	*/

	
//Savkizaras (sas video)
	/*
	VideoCapture sas;
	sas.open("D:/fontosak/info/kepfeldolgozas/kepek/sas.avi");
	if (sas.isOpened()) {
		cout << "begagandodam" << endl;
	}
	Mat current;
	int hanyadik = 0;
	while (true) {
		sas >> current;
		if (current.empty()) {
			break;
		}
		hanyadik++;
		Mat hatter = current.clone();
		cvtColor(hatter, hatter, COLOR_BGR2GRAY);
		Mat mask;
		inRange(hatter, 100, 155, mask);
		medianBlur(mask, mask, 5);
		hatter.setTo(0,mask);
		imshow("kep", hatter);
		imwrite("D:/fontosak/info/kepfeldolgozas/kepek/sas/sas" + to_string(hanyadik) + ".jpg", hatter);
		waitKey(33);

	}
	*/


//Kuszoboles rogzitett ertekkel
	/*
	Mat sejtek = imread("D:/fontosak/info/kepfeldolgozas/kepek/sejtek.png", IMREAD_GRAYSCALE);
	int x = 0, y = 0, szamlalo = 1;
	for (int i = 0; i <= 255; i += 20) {
		Mat dest;
		namedWindow(to_string(szamlalo)+" kuszobertek", WINDOW_NORMAL);
		threshold(sejtek,dest,i,255,THRESH_BINARY);
		resizeWindow(to_string(szamlalo) + " kuszobertek", Size(300, 300));
		moveWindow(to_string(szamlalo) + " kuszobertek", x, y);
		szamlalo++;

		imshow(to_string(szamlalo) + " kuszobertek", dest);

		x += 320;
		if (x > 1080) {
			x = 0;
			y += 320;
		}

	}
	*/


//Adaptiv kuszoboles (skippeltem egyelore)
	/*
	Mat zh = imread("D:/fontosak/info/kepfeldolgozas/kepek/zh.jpg", IMREAD_GRAYSCALE);
	imshow("zh", zh);
	*/


//Morfologia
	//kod eltavolitas
	/*
	Mat galaxy = imread("D:/fontosak/info/kepfeldolgozas/kepek/galaxy.jpg", IMREAD_GRAYSCALE);
	imshow("galaxy", galaxy);
	Mat dest;
	Mat border = getStructuringElement(MORPH_RECT, Size(5, 5));
	morphologyEx(galaxy, dest, MORPH_TOPHAT, border);
	imshow("dest", dest);
	*/

	//kutya zajszures
	/*
	Mat kugya = imread("D:/fontosak/info/kepfeldolgozas/kepek/dog.jpg", IMREAD_GRAYSCALE);
	imshow("kutya", kugya);
	Mat dest, border;
	threshold(kugya, dest, 100, 255, THRESH_BINARY);
	imshow("kuszob", dest);
	border = getStructuringElement(MORPH_RECT, Size(5, 5));
	morphologyEx(dest, dest, MORPH_OPEN, border);
	imshow("eredmeny", dest);
	*/

	//sajt
	/*
	Mat sajt = imread("D:/fontosak/info/kepfeldolgozas/kepek/sajt.png",IMREAD_GRAYSCALE);
	Mat korvonal, kitoltott, binaris;
	imshow("sajt", sajt);
	Mat border = getStructuringElement(MORPH_RECT, Size(4, 4));
	Mat border2 = getStructuringElement(MORPH_ELLIPSE, Size(80, 80));
	threshold(sajt, binaris, 250, 255, THRESH_BINARY_INV);
	medianBlur(binaris, binaris, 5);
	imshow("binaris", binaris);
	morphologyEx(sajt, korvonal, MORPH_GRADIENT, border);
	imshow("sex", korvonal);
	morphologyEx(binaris, kitoltott, MORPH_CLOSE, border2, Point(-1,-1),1, BORDER_CONSTANT,0);
	imshow("toltott", kitoltott);
	*/

	//szitakoto
	/*
	Mat szita = imread("D:/fontosak/info/kepfeldolgozas/kepek/szitakoto.jpg", IMREAD_GRAYSCALE), dest;
	imshow("og", szita);
	Mat result, kivonni;
	threshold(szita, dest, 100, 255, THRESH_BINARY_INV);
	medianBlur(dest, dest, 3);
	imshow("kivagott", dest);
	Mat border = getStructuringElement(MORPH_RECT, Size(6, 6));
	morphologyEx(dest, kivonni, MORPH_TOPHAT, border);
	subtract(dest, kivonni, result);
	cout << countNonZero(result);
	imshow("dest", result);
	*/

	//sejtek
	/*
	Mat sejt = imread("D:/fontosak/info/kepfeldolgozas/kepek/annotalt_sejt.png",IMREAD_COLOR);
	vector<Mat> chs;
	vector<Point> pixelek;
	split(sejt, chs);
	Mat dest;
	imshow("piros", chs[2]);
	threshold(chs[2], dest, 250, 255, THRESH_BINARY);
	Mat border = getStructuringElement(MORPH_CROSS, Size(3, 3));
	morphologyEx(dest, dest, MORPH_HITMISS, border);
	for (int i = 0; i < dest.rows; ++i) {
		for (int j = 0; j < dest.cols; ++j) {
			if (dest.at<uchar>(i, j)) {
				pixelek.push_back(Point(j, i));
			}
		}
	}
	Mat sejt2 = sejt.clone();
	for (auto p : pixelek) {
		drawMarker(sejt2, p, Scalar(0, 255, 0), MARKER_CROSS,10,2);
	}
	imshow("kaksi",sejt2);
	moveWindow("kaksi", 320, 300);
	*/

	//kep sotitetes/vilagositasa
	/*
	Mat graycat = imread("D:/fontosak/info/kepfeldolgozas/kepek/graycat.jpg", IMREAD_GRAYSCALE);
	Mat erode, dilate, open;
	imshow("macsek", graycat);
	Mat border = getStructuringElement(MORPH_ELLIPSE, Size(10, 10));
	morphologyEx(graycat, erode, MORPH_ERODE, border);
	imshow("erode", erode);
	morphologyEx(graycat, dilate, MORPH_DILATE, border);
	imshow("dilate", dilate);
	morphologyEx(graycat, open, MORPH_OPEN, border);
	imshow("open", open);
	*/

//ppt gyakorlo -3
	//1.
	/*
	Mat abc = imread("D:/fontosak/info/kepfeldolgozas/kepek/abc.jpg", IMREAD_GRAYSCALE);
	imshow("abc", abc);
	threshold(abc, abc, 128, 255, THRESH_BINARY_INV);
	imshow("invabc", abc);
	Mat border = getStructuringElement(MORPH_RECT, Size(10, 10));
	morphologyEx(abc, abc, MORPH_ERODE, border,Point(-1,-1), 1,BORDER_CONSTANT,0);
	imshow("kisabc", abc);
	*/
	
	//2
	/*
	Mat abc = imread("D:/fontosak/info/kepfeldolgozas/kepek/abc.jpg", IMREAD_GRAYSCALE);
	imshow("abc", abc);
	threshold(abc, abc, 128, 255, THRESH_BINARY_INV);
	imshow("invabc", abc);
	Mat border = getStructuringElement(MORPH_RECT, Size(8, 8));
	morphologyEx(abc, abc, MORPH_DILATE, border, Point(-1, -1), 1, BORDER_CONSTANT, 0);
	imshow("nagyabc", abc);
	*/

	//3
	/*
	Mat abc = imread("D:/fontosak/info/kepfeldolgozas/kepek/abc.jpg", IMREAD_GRAYSCALE);
	imshow("abc", abc);
	threshold(abc, abc, 128, 255, THRESH_BINARY_INV);
	imshow("invabc", abc);
	Mat border = getStructuringElement(MORPH_RECT, Size(8, 8));
	morphologyEx(abc, abc, MORPH_GRADIENT, border, Point(-1, -1), 1, BORDER_CONSTANT, 0);
	imshow("korvonal", abc);
	*/

	//4
	/*
	Mat otos = imread("D:/fontosak/info/kepfeldolgozas/kepek/otos.png", IMREAD_GRAYSCALE);
	imshow("ot", otos);
	threshold(otos, otos, 128, 255, THRESH_BINARY_INV);
	imshow("invot", otos);
	Mat border = getStructuringElement(MORPH_RECT, Size(8, 8));
	morphologyEx(otos, otos, MORPH_GRADIENT, border, Point(-1, -1), 1, BORDER_CONSTANT, 0);
	imshow("korvonal", otos);
	*/

	//5
	/*
	Mat ujjlenyomat = imread("D:/fontosak/info/kepfeldolgozas/kepek/ujjlenyomat.png", IMREAD_GRAYSCALE);
	imshow("ujjlenyomat", ujjlenyomat);
	threshold(ujjlenyomat, ujjlenyomat, 128, 255, THRESH_BINARY);
	imshow("invujjlenyomat", ujjlenyomat);
	Mat border = getStructuringElement(MORPH_ELLIPSE, Size(3, 3));
	morphologyEx(ujjlenyomat, ujjlenyomat, MORPH_ERODE, border);
	imshow("szort", ujjlenyomat);
	*/

	//6
	/*
	Mat coin = imread("D:/fontosak/info/kepfeldolgozas/kepek/coins2.jpg", IMREAD_GRAYSCALE);
	imshow("coin", coin);
	inRange(coin, 250, 255, coin);
	medianBlur(coin, coin, 5);
	imshow("invcoin", coin);
	coin = 255 - coin;
	Mat border = getStructuringElement(MORPH_RECT, Size(2, 2));
	morphologyEx(coin, coin, MORPH_OPEN, border, Point(-1, -1), 1, BORDER_CONSTANT, 0);
	Mat border2 = getStructuringElement(MORPH_ELLIPSE, Size(80, 80));
	morphologyEx(coin, coin, MORPH_ERODE, border2);
	imshow("megoldas", coin);
	*/



//Robert gradiens
	/*
	Mat kep = imread("D:/fontosak/info/kepfeldolgozas/kepek/go2.png", IMREAD_GRAYSCALE);
	resize(kep, kep, (Size(kep.rows / 4, kep.cols / 4)));
	Mat g1 = Mat::zeros(kep.size(), CV_16S);
	Mat g2 = Mat::zeros(kep.size(), CV_16S);
	for (int i = 0; i < kep.rows-1; ++i) {
		for (int j = 0; j < kep.cols-1; ++j) {
			g1.at<short>(i, j) = kep.at<uchar>(i, j) - kep.at<uchar>(i + 1, j + 1);
			g2.at<short>(i, j) = kep.at<uchar>(i+1, j) - kep.at<uchar>(i, j + 1);
		}
	}
	Mat G = g1 + g2;
	convertScaleAbs(G, G);
	imshow("gradiens", G);
	threshold(G, G, 40, 255,THRESH_BINARY);
	imshow("eredmeny", G);
	*/


//Gradient nagysaga
	/*
	Mat kep = imread("D:/fontosak/info/kepfeldolgozas/kepek/go2.png", IMREAD_GRAYSCALE);
	Mat dx, dy;
	Sobel(kep, dx, CV_32F, 1, 0);
	Sobel(kep, dy, CV_32F, 0, 1);
	imshow("dx", dx);
	imshow("dy", dy);
	Mat dx2 = dx.mul(dx);
	Mat dy2 = dy.mul(dy);
	Mat G;
	sqrt(dx2 + dy2, G);
	Mat dest;
	convertScaleAbs(G, dest);
	threshold(dest, dest, 80, 150, THRESH_BINARY);
	Mat border = getStructuringElement(MORPH_ELLIPSE, Size(2, 2));
	morphologyEx(dest, dest, MORPH_OPEN, border);
	imshow("dest", dest);
	*/


//Gradient nagysaganak kozelitese
	/*
	Mat kep = imread("D:/fontosak/info/kepfeldolgozas/kepek/go2.png", IMREAD_GRAYSCALE);
	Mat dx, dy;
	Sobel(kep, dx, CV_32F, 1, 0);
	Sobel(kep, dy, CV_32F, 0, 1);
	imshow("dx", dx);
	imshow("dy", dy);
	Mat G;
	add(dx,dy,G);
	Mat dest;
	convertScaleAbs(G, dest);
	threshold(dest, dest, 80, 150, THRESH_BINARY);
	Mat border = getStructuringElement(MORPH_ELLIPSE, Size(2, 2));
	morphologyEx(dest, dest, MORPH_OPEN, border);
	imshow("dest", dest);
	*/


//Hough Circles
	/*
	Mat kep = imread("D:/fontosak/info/kepfeldolgozas/kepek/g2.png", IMREAD_GRAYSCALE);
	vector<Vec3f> circles;
	HoughCircles(kep, circles, HOUGH_GRADIENT, 2, 50, 80, 50, 20, 25);
	Mat szines;
	cvtColor(kep, szines, COLOR_GRAY2BGR);
	for (auto c : circles) {
		Point center(cvRound(c[0]), cvRound(c[1]));
		int radius = cvRound(c[2]);
		uchar fenyero = kep.at<uchar>(center);
		if (fenyero > 200) {
			circle(szines, center, radius, Scalar(0, 255, 0), 2);
		}
		else {
			circle(szines, center, radius, Scalar(255, 0, 0), 2);
		}
	}
	imshow("eredmeny", szines);
	*/




	waitKey(0);
	destroyAllWindows();
	return 0;
}