ImreDavidProject.cpp

// OpenCVApplication.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "common.h"
#include <opencv2/core/utils/logger.hpp>
#include <random>
#include <queue>
#include <fstream>
#include <opencv2/opencv.hpp>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <cmath>
#include <iostream>



using namespace std;
wchar_t* projectPath;

void testOpenImage()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src;
		src = imread(fname);
		imshow("image", src);
		waitKey();
	}
}

void testOpenImagesFld()
{
	char folderName[MAX_PATH];
	if (openFolderDlg(folderName) == 0)
		return;
	char fname[MAX_PATH];
	FileGetter fg(folderName, "bmp");
	while (fg.getNextAbsFile(fname))
	{
		Mat src;
		src = imread(fname);
		imshow(fg.getFoundFileName(), src);
		if (waitKey() == 27) //ESC pressed
			break;
	}
}

void testImageOpenAndSave()
{
	_wchdir(projectPath);

	Mat src, dst;

	src = imread("Images/Lena_24bits.bmp", IMREAD_COLOR);	// Read the image

	if (!src.data)	// Check for invalid input
	{
		printf("Could not open or find the image\n");
		return;
	}

	// Get the image resolution
	Size src_size = Size(src.cols, src.rows);

	// Display window
	const char* WIN_SRC = "Src"; //window for the source image
	namedWindow(WIN_SRC, WINDOW_AUTOSIZE);
	moveWindow(WIN_SRC, 0, 0);

	const char* WIN_DST = "Dst"; //window for the destination (processed) image
	namedWindow(WIN_DST, WINDOW_AUTOSIZE);
	moveWindow(WIN_DST, src_size.width + 10, 0);

	cvtColor(src, dst, COLOR_BGR2GRAY); //converts the source image to a grayscale one

	imwrite("Images/Lena_24bits_gray.bmp", dst); //writes the destination to file

	imshow(WIN_SRC, src);
	imshow(WIN_DST, dst);

	waitKey(0);
}

void testNegativeImage()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		double t = (double)getTickCount(); // Get the current time [s]

		Mat src = imread(fname, IMREAD_GRAYSCALE);
		int height = src.rows;
		int width = src.cols;
		Mat dst = Mat(height, width, CV_8UC1);
		// Accessing individual pixels in an 8 bits/pixel image
		// Inefficient way -> slow
		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				uchar val = src.at<uchar>(i, j);
				uchar neg = 255 - val;
				dst.at<uchar>(i, j) = neg;
			}
		}

		// Get the current time again and compute the time difference [s]
		t = ((double)getTickCount() - t) / getTickFrequency();
		// Print (in the console window) the processing time in [ms] 
		printf("Time = %.3f [ms]\n", t * 1000);

		imshow("input image", src);
		imshow("negative image", dst);
		waitKey();
	}
}

void changeGrayLevel()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		double t = (double)getTickCount(); // Get the current time [s]

		Mat src = imread(fname, IMREAD_GRAYSCALE);
		int height = src.rows;
		int width = src.cols;
		Mat dst = Mat(height, width, CV_8UC1);
		// Accessing individual pixels in an 8 bits/pixel image
		// Inefficient way -> slow
		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				uchar val = src.at<uchar>(i, j);
				uint32_t chgGray = val * 1.5;
				if (chgGray > 255) {
					chgGray = 255;
				}
				dst.at<uchar>(i, j) = (uchar)chgGray;
			}
		}

		// Get the current time again and compute the time difference [s]
		t = ((double)getTickCount() - t) / getTickFrequency();
		// Print (in the console window) the processing time in [ms] 
		printf("Time = %.3f [ms]\n", t * 1000);

		imshow("input image", src);
		imshow("brighter image", dst);
		waitKey();
	}
}

void quartersColoured()
{
	int height = 300;
	int width = 500;
	Mat dst(height, width, CV_8UC3);
	for (int i = 0; i < height; i++)
		for (int j = 0; j < width; j++) {
			if (i < height / 2 & j < width / 2)
			{
				dst.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
			}
			if (i < height / 2 & j > width / 2)
			{
				dst.at<Vec3b>(i, j) = Vec3b(0, 0, 255);
			}
			if (i > height / 2 & j < width / 2)
			{
				dst.at<Vec3b>(i, j) = Vec3b(0, 255, 0);
			}
			if (i > height / 2 & j > width / 2)
			{
				dst.at<Vec3b>(i, j) = Vec3b(0, 255, 255);
			}
		}

	imshow("4-squared coloured image", dst);
	waitKey();
}
void floatMat()
{
	float vals[4] = { 1, 2, 3, 4 };
	Mat M(2, 2, CV_32FC1, vals); //4 parameter constructor
	std::cout << M << std::endl;
	Mat x = M.inv();
	std::cout << x << std::endl;
	getchar();
	getchar();

}
void testNegativeImageFast()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src = imread(fname, IMREAD_GRAYSCALE);
		int height = src.rows;
		int width = src.cols;
		Mat dst = src.clone();

		double t = (double)getTickCount(); // Get the current time [s]

		// The fastest approach of accessing the pixels -> using pointers
		uchar* lpSrc = src.data;
		uchar* lpDst = dst.data;
		int w = (int)src.step; // no dword alignment is done !!!
		for (int i = 0; i < height; i++)
			for (int j = 0; j < width; j++) {
				uchar val = lpSrc[i * w + j];
				lpDst[i * w + j] = 255 - val;
			}

		// Get the current time again and compute the time difference [s]
		t = ((double)getTickCount() - t) / getTickFrequency();
		// Print (in the console window) the processing time in [ms] 
		printf("Time = %.3f [ms]\n", t * 1000);

		imshow("input image", src);
		imshow("negative image", dst);
		waitKey();
	}
}

void testColor2Gray()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src = imread(fname);

		int height = src.rows;
		int width = src.cols;

		Mat dst = Mat(height, width, CV_8UC1);

		// Accessing individual pixels in a RGB 24 bits/pixel image
		// Inefficient way -> slow
		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				Vec3b v3 = src.at<Vec3b>(i, j);
				uchar b = v3[0];
				uchar g = v3[1];
				uchar r = v3[2];
				dst.at<uchar>(i, j) = (r + g + b) / 3;
			}
		}

		imshow("input image", src);
		imshow("gray image", dst);
		waitKey();
	}
}

void test4Quadrants()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src = imread(fname);

		int height = src.rows;
		int width = src.cols;

		Mat first = Mat(height, width, CV_8UC3);
		Mat second = Mat(height, width, CV_8UC3);
		Mat third = Mat(height, width, CV_8UC3);


		// Accessing individual pixels in a RGB 24 bits/pixel image
		// Inefficient way -> slow

		int halfHeight = height / 2;
		int halfWidth = width / 2;

		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				Vec3b v3 = src.at<Vec3b>(i, j);
				uchar b = v3[0];
				uchar g = v3[1];
				uchar r = v3[2];

				first.at<Vec3b>(i, j) = Vec3b(b, b, b);
				second.at<Vec3b>(i, j) = Vec3b(r, r, r);
				third.at<Vec3b>(i, j) = Vec3b(g, g, g);
			}
		}

		imshow("input image", src);
		imshow("quadrant image", first);
		imshow("quadrant2 image", second);
		imshow("quadrant3 image", third);
		waitKey();
	}
}

void testBGR2HSV()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src = imread(fname);
		int height = src.rows;
		int width = src.cols;

		// HSV components
		Mat H = Mat(height, width, CV_8UC1);
		Mat S = Mat(height, width, CV_8UC1);
		Mat V = Mat(height, width, CV_8UC1);

		// Defining pointers to each matrix (8 bits/pixels) of the individual components H, S, V 
		uchar* lpH = H.data;
		uchar* lpS = S.data;
		uchar* lpV = V.data;

		Mat hsvImg;
		cvtColor(src, hsvImg, COLOR_BGR2HSV);

		// Defining the pointer to the HSV image matrix (24 bits/pixel)
		uchar* hsvDataPtr = hsvImg.data;

		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				int hi = i * width * 3 + j * 3;
				int gi = i * width + j;

				lpH[gi] = hsvDataPtr[hi] * 510 / 360;	// lpH = 0 .. 255
				lpS[gi] = hsvDataPtr[hi + 1];			// lpS = 0 .. 255
				lpV[gi] = hsvDataPtr[hi + 2];			// lpV = 0 .. 255
			}
		}

		imshow("input image", src);
		imshow("H", H);
		imshow("S", S);
		imshow("V", V);

		waitKey();
	}
}

void testResize()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src;
		src = imread(fname);
		Mat dst1, dst2;
		//without interpolation
		resizeImg(src, dst1, 320, false);
		//with interpolation
		resizeImg(src, dst2, 320, true);
		imshow("input image", src);
		imshow("resized image (without interpolation)", dst1);
		imshow("resized image (with interpolation)", dst2);
		waitKey();
	}
}
void testColortoGrayscale()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src = imread(fname);

		int height = src.rows;
		int width = src.cols;

		Mat dst = Mat(height, width, CV_8UC3);


		// Accessing individual pixels in a RGB 24 bits/pixel image
		// Inefficient way -> slow

		int halfHeight = height / 2;
		int halfWidth = width / 2;

		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				Vec3b v3 = src.at<Vec3b>(i, j);
				uchar b = v3[0];
				uchar g = v3[1];
				uchar r = v3[2];

				float gray = (b + g + r) / 3;

				dst.at<Vec3b>(i, j) = Vec3b((uchar)gray, (uchar)gray, (uchar)gray);

			}
		}

		imshow("input image", src);
		imshow("gray image", dst);

		waitKey();
	}
}

void computeAndDisplayHSVMatrix()
{
	char fname[MAX_PATH];
	if (openFileDlg(fname))
	{
		Mat src = imread(fname);


		int height = src.rows;
		int width = src.cols;

		// HSV components
		Mat H = Mat(height, width, CV_8UC1);
		Mat S = Mat(height, width, CV_8UC1);
		Mat V = Mat(height, width, CV_8UC1);

		// Convert the image from BGR to HSV
		Mat hsvImg;
		cvtColor(src, hsvImg, COLOR_BGR2HSV);

		// Iterate through each pixel in the HSV image and compute H, S, and V
		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				Vec3b hsv = hsvImg.at<Vec3b>(i, j);
				H.at<uchar>(i, j) = hsv[0] * 255 / 180; // H: 0-180
				S.at<uchar>(i, j) = hsv[1]; // S: 0-255
				V.at<uchar>(i, j) = hsv[2]; // V: 0-255
			}
		}

		// Display the original image and the HSV components
		imshow("Original Image", src);
		imshow("Hue (H)", H);
		imshow("Saturation (S)", S);
		imshow("Value (V)", V);
		waitKey();
	}
}
bool isInside(Mat img, int i, int j) {
	if ((i < img.rows) && (j < img.cols) && (i >= 0) && (j >= 0))
		return true;
	else
		return false;

}


void checkIfInsideImage() {
	// Directly specify the folder and image names
	const char* imageName = "C:/path/to/your/image/image.bmp";
	const char* folderName = "C:/path/to/your/folder";

	// Load the image
	Mat img = imread(imageName);
	if (img.empty()) {
		cerr << "Error: Unable to load image '" << imageName << "'" << endl;
		return;
	}

	// Display the loaded image
	imshow("Loaded Image", img);
	waitKey();

	// Check if a specific point is inside the loaded image
	int i, j;
	cout << "Enter the row index (i): ";
	cin >> i;
	cout << "Enter the column index (j): ";
	cin >> j;

	// Check if the coordinates are inside the image
	if (isInside(img, i, j)) {
		cout << "The point (" << i << ", " << j << ") is inside the image." << endl;
	}
	else {
		cout << "The point (" << i << ", " << j << ") is outside the image." << endl;
	}
}







void testGraytoBinary()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src;
		src = imread(fname, IMREAD_GRAYSCALE);
		imshow("Grayscale Image", src);

		int thresholdValue;
		cout << "Enter threshold value: ";
		cin >> thresholdValue;

		Mat binaryImage;
		threshold(src, binaryImage, thresholdValue, 255, THRESH_BINARY);

		imshow("Binary Image", binaryImage);
		waitKey();
	}
}


void testCanny()
{
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		Mat src, dst, gauss;
		src = imread(fname, IMREAD_GRAYSCALE);
		double k = 0.4;
		int pH = 50;
		int pL = (int)k * pH;
		GaussianBlur(src, gauss, Size(5, 5), 0.8, 0.8);
		Canny(gauss, dst, pL, pH, 3);
		imshow("input image", src);
		imshow("canny", dst);
		waitKey();
	}
}

void testVideoSequence()
{
	_wchdir(projectPath);

	VideoCapture cap("Videos/rubic.avi"); // off-line video from file
	//VideoCapture cap(0);	// live video from web cam
	if (!cap.isOpened()) {
		printf("Cannot open video capture device.\n");
		waitKey(0);
		return;
	}

	Mat edges;
	Mat frame;
	char c;

	while (cap.read(frame))
	{
		Mat grayFrame;
		cvtColor(frame, grayFrame, COLOR_BGR2GRAY);
		Canny(grayFrame, edges, 40, 100, 3);
		imshow("source", frame);
		imshow("gray", grayFrame);
		imshow("edges", edges);
		c = waitKey(100);  // waits 100ms and advances to the next frame
		if (c == 27) {
			// press ESC to exit
			printf("ESC pressed - capture finished\n");
			break;  //ESC pressed
		};
	}
}

/* Histogram display function - display a histogram using bars (simlilar to L3 / PI)
Input:
name - destination (output) window name
hist - pointer to the vector containing the histogram values
hist_cols - no. of bins (elements) in the histogram = histogram image width
hist_height - height of the histogram image
Call example:
showHistogram ("MyHist", hist_dir, 255, 200);
*/
void showHistogram(const std::string& name, int* hist, const int  hist_cols, const int hist_height)
{
	Mat imgHist(hist_height, hist_cols, CV_8UC3, CV_RGB(255, 255, 255)); // constructs a white image

	//computes histogram maximum
	int max_hist = 0;
	for (int i = 0; i < hist_cols; i++)
		if (hist[i] > max_hist)
			max_hist = hist[i];
	double scale = 1.0;
	scale = (double)hist_height / max_hist;
	int baseline = hist_height - 1;

	for (int x = 0; x < hist_cols; x++) {
		Point p1 = Point(x, baseline);
		Point p2 = Point(x, baseline - cvRound(hist[x] * scale));
		line(imgHist, p1, p2, CV_RGB(255, 102, 0)); // histogram bins colored in orange
	}

	imshow(name, imgHist);
}

void testSnap()
{
	_wchdir(projectPath);

	VideoCapture cap(0); // open the deafult camera (i.e. the built in web cam)
	if (!cap.isOpened()) // openenig the video device failed
	{
		printf("Cannot open video capture device.\n");
		return;
	}

	Mat frame;
	char numberStr[256];
	char fileName[256];

	// video resolution
	Size capS = Size((int)cap.get(CAP_PROP_FRAME_WIDTH),
		(int)cap.get(CAP_PROP_FRAME_HEIGHT));

	// Display window
	const char* WIN_SRC = "Src"; //window for the source frame
	namedWindow(WIN_SRC, WINDOW_AUTOSIZE);
	moveWindow(WIN_SRC, 0, 0);

	const char* WIN_DST = "Snapped"; //window for showing the snapped frame
	namedWindow(WIN_DST, WINDOW_AUTOSIZE);
	moveWindow(WIN_DST, capS.width + 10, 0);

	char c;
	int frameNum = -1;
	int frameCount = 0;

	for (;;)
	{
		cap >> frame; // get a new frame from camera
		if (frame.empty())
		{
			printf("End of the video file\n");
			break;
		}

		++frameNum;

		imshow(WIN_SRC, frame);

		c = waitKey(10);  // waits a key press to advance to the next frame
		if (c == 27) {
			// press ESC to exit
			printf("ESC pressed - capture finished");
			break;  //ESC pressed
		}
		if (c == 115) { //'s' pressed - snap the image to a file
			frameCount++;
			fileName[0] = NULL;
			sprintf(numberStr, "%d", frameCount);
			strcat(fileName, "Images/A");
			strcat(fileName, numberStr);
			strcat(fileName, ".bmp");
			bool bSuccess = imwrite(fileName, frame);
			if (!bSuccess)
			{
				printf("Error writing the snapped image\n");
			}
			else
				imshow(WIN_DST, frame);
		}
	}

}

void histogram() {
	int x[256] = {};
	int x2[256] = {};
	int W;
	scanf("%d", &W);
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				x[img.at<uchar>(i, j)]++;

			}
		}
		for (int i = 0; i < 256; i++) {
			printf("[%d]-> %d ", i, x[i]);

		}
		for (int k = W / 2; k < (256 - W / 2); k++) {
			for (int j = k - W / 2; j <= k + W / 2; j++) {

				imshow("histogram", img);
				waitKey(0);

			}
		}
	}
}

void PDF() {
	int x[256] = {};
	float y[256] = {};
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				x[img.at<uchar>(i, j)]++;

			}
		}
		for (int i = 0; i < 256; i++) {
			y[i] = (float)x[i] / (img.rows * img.cols);
			printf("[%d]-> %f ", i, y[i]);

		}
		imshow("PDF", img);
		waitKey(0);
	}
}

void printHistogram() {
	int x[256] = {};
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				x[img.at<uchar>(i, j)]++;

			}
		}
		showHistogram("histogram", x, 256, 300);
		waitKey(0);
	}
}

void histogramLower() {
	int x[128] = {};
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				int var = 0.5 * img.at<uchar>(i, j);
				x[var]++;

			}
		}
		for (int i = 0; i < 128; i++) {
			printf("[%d]-> %d ", i, x[i]);

		}
		showHistogram("histogram", x, 128, 300);
		waitKey(0);
	}
}

void threshHold() {
	int WH = 5;
	int TH = 0.0003;
	float v;
	int val;
	int vec[255];
	int count = 1;
	int x[256] = {};
	float y[256] = {};
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				x[img.at<uchar>(i, j)]++;

			}
		}
		for (int i = 0; i < 256; i++) {
			y[i] = (float)x[i] / (img.rows * img.cols);
		}

		for (int k = WH; k <= 255 - WH; k++) {
			v = 0;
			for (int i = k - WH; i <= k + WH; i++) {
				v += y[i];
				if (y[i] > y[k])
					v += 1000;
			}
			v = v / (2 * WH + 1);
			if (y[k] > v + TH) {
				vec[count] = k;
				count++;
			}
		}
		vec[0] = 0;
		vec[count] = 255;

		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				val = img.at<uchar>(i, j);
				int min = 255;
				int close;
				for (int z = 0; z < count + 1; z++) {
					if (abs(val - vec[z]) < min) {
						min = abs(val - vec[z]);
						close = vec[z];
					}
				}
				img.at<uchar>(i, j) = close;
			}
		}
		imshow("threshHold", img);
		waitKey();
	}
}

void FloydSteinberg() {
	int WH = 5;
	float TH = 0.0003;
	float v;
	int val;
	int vec[255];
	int count = 1;
	int x[256] = {};
	float y[256] = {};
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				x[img.at<uchar>(i, j)]++;

			}
		}
		for (int i = 0; i < 256; i++) {
			y[i] = (float)x[i] / (img.rows * img.cols);
		}

		for (int k = WH; k <= 255 - WH; k++) {
			v = 0;
			for (int i = k - WH; i <= k + WH; i++) {
				v += y[i];
				if (y[i] > y[k])
					v += 1000;
			}
			v = v / (2 * WH + 1);
			if (y[k] > v + TH) {
				vec[count] = k;
				count++;
			}
		}
		vec[0] = 0;
		vec[count] = 255;

		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				val = img.at<uchar>(i, j);
				int min = 256;
				int close;
				for (int z = 0; z < count + 1; z++) {
					if (abs(vec[z] - val) < min) {
						min = abs(vec[z] - val);
						close = vec[z];
					}
				}
				img.at<uchar>(i, j) = close;
				int error = val - close;
				if (isInside(img, i + 1, j) == true) {
					if ((img.at<uchar>(i + 1, j) + 7 * error / 16) < 0)
						img.at<uchar>(i + 1, j) = 0;
					else if ((img.at<uchar>(i + 1, j) + 7 * error / 16) > 255)
						img.at<uchar>(i + 1, j) = 255;
					else
						img.at<uchar>(i + 1, j) = img.at<uchar>(i + 1, j) + 7 * error / 16;
				}

				if (isInside(img, i - 1, j + 1) == true) {
					if ((img.at<uchar>(i - 1, j + 1) + 3 * error / 16) < 0)
						img.at<uchar>(i - 1, j + 1) = 0;
					else if ((img.at<uchar>(i - 1, j + 1) + 3 * error / 16) > 255)
						img.at<uchar>(i - 1, j + 1) = 255;
					else
						img.at<uchar>(i - 1, j + 1) = img.at<uchar>(i - 1, j + 1) + 3 * error / 16;
				}

				if (isInside(img, i, j + 1) == true) {
					if ((img.at<uchar>(i, j + 1) + 5 * error / 16) < 0)
						img.at<uchar>(i, j + 1) = 0;
					else if ((img.at<uchar>(i, j + 1) + 5 * error / 16) > 255)
						img.at<uchar>(i, j + 1) = 255;
					else
						img.at<uchar>(i, j + 1) = img.at<uchar>(i, j + 1) + 5 * error / 16;
				}
				if (isInside(img, i + 1, j + 1) == true) {
					if ((img.at<uchar>(i + 1, j + 1) + error / 16) < 0)
						img.at<uchar>(i + 1, j + 1) = 0;
					else if ((img.at<uchar>(i + 1, j + 1) + error / 16) > 255)
						img.at<uchar>(i + 1, j + 1) = 255;
					else
						img.at<uchar>(i + 1, j + 1) = img.at<uchar>(i + 1, j + 1) + error / 16;
				}

			}
		}
		imshow("floyd", img);
		waitKey();
	}
}

void MyCallBackFunction(int event, int x, int y, int flags, void* param)
{
	Mat* src = (Mat*)param;
	Vec3b pixel;
	int area = 0;
	int row = 0, col = 0;
	int row2, col2;
	int axis = 0, axis2 = 0;
	int phi;
	int perry = 0;
	float thickness = 0;
	float RRR;
	int imin = 999999, jmin = 999999, imax = -1, jmax = -1;
	if (event == EVENT_LBUTTONDOWN)
	{
		printf("Pos(x,y): %d,%d  Color(RGB): %d,%d,%d\n",
			x, y,
			(int)(*src).at<Vec3b>(y, x)[2],
			(int)(*src).at<Vec3b>(y, x)[1],
			(int)(*src).at<Vec3b>(y, x)[0]);
		pixel = Vec3b((*src).at<Vec3b>(y, x)[0], (*src).at<Vec3b>(y, x)[1], (*src).at<Vec3b>(y, x)[2]);
		for (int i = 0; i < src->rows; i++) {
			for (int j = 0; j < src->cols; j++) {
				if (pixel == src->at<Vec3b>(i, j)) {
					area++;
					row += i;
					col += j;
					if ((src->at<Vec3b>(i + 1, j) != pixel) || (src->at<Vec3b>(i, j + 1) != pixel) ||
						(src->at<Vec3b>(i - 1, j) != pixel) || (src->at<Vec3b>(i, j - 1) != pixel) ||
						(src->at<Vec3b>(i - 1, j - 1) != pixel) || (src->at<Vec3b>(i + 1, j + 1) != pixel) ||
						(src->at<Vec3b>(i - 1, j + 1) != pixel) || (src->at<Vec3b>(i + 1, j - 1) != pixel))
						perry++;
					if (i < imin)
						imin = i;
					if (i > imax)
						imax = i;
					if (j < jmin)
						jmin = j;
					if (j > jmax)
						jmax = j;
				}
			}
		}
		row2 = row / area;
		col2 = col / area;
		printf("The area is: %d \n", area);
		printf("The center of mass is (%d, %d)\n", row2, col2);
		for (int i = 0; i < src->rows; i++) {
			for (int j = 0; j < src->cols; j++) {
				if (pixel == src->at<Vec3b>(i, j)) {
					axis += (i - row2) * (j - col2);
					axis2 += pow((j - col2), 2) - pow((i - row2), 2);
				}
			}
		}
		axis = axis * 2;
		float axa3 = atan2(axis, axis2);
		phi = axa3 * (180 / CV_PI);
		phi = phi / 2;
		if (phi < 0)
			phi += 180;
		printf("The axis of elongation is: %d\n", phi);
		perry = perry * (CV_PI / 4);
		printf("The perimeter is: %d \n", perry);
		thickness = 4 * CV_PI * ((float)area / pow(perry, 2));
		printf("The thinness ratio is: %f\n", thickness);
		RRR = (float)(jmax - jmin + 1) / (imax - imin + 1);
		printf("The aspect ratio is: %f\n", RRR);
	}
}

void MouseClick()
{
	Mat src;
	// Read image from file 
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		src = imread(fname);
		//Create a window
		namedWindow("blabla window", 1);

		//set the callback function for any mouse event
		setMouseCallback("blabla window", MyCallBackFunction, &src);

		//show the image
		imshow("blabla window", src);

		// Wait until user press some key
		waitKey(0);
	}
}


void labeling()
{
	int di[8] = { -1, -1, -1, 0, 0, 1, 1, 1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	//could use for a 4-neighbourhood di[4]={-1, 0, 1, 0} and dj[4]= {0, -1, 0, 1}
	uchar val;
	uchar label = 0;
	uchar maxLabel = 0;
	std::default_random_engine gen;
	std::uniform_int_distribution<int> d(0, 255);
	Vec3b color;
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat image = imread(fname, IMREAD_GRAYSCALE);
		Mat labels = Mat::zeros(image.rows, image.cols, CV_8UC1);
		Mat show(image.rows, image.cols, CV_8UC3, Scalar(255, 255, 255));
		for (int i = 1; i < image.rows - 1; i++) {
			for (int j = 1; j < image.cols - 1; j++) {
				val = image.at<uchar>(i, j);
				if ((val == 0) && (labels.at<uchar>(i, j) == 0)) {
					label++;
					std::queue<Point> Q;
					labels.at<uchar>(i, j) = label;
					Q.push({ i,j });
					while (!Q.empty()) {
						Point q = Q.front();
						Q.pop();
						for (int k = 0; k < 8; k++) {
							if ((image.at<uchar>(q.x + di[k], q.y + dj[k]) == 0) && (labels.at<uchar>(q.x + di[k], q.y + dj[k]) == 0)) {
								labels.at<uchar>(q.x + di[k], q.y + dj[k]) = label;
								Q.push({ q.x + di[k], q.y + dj[k] });
							}
						}
					}
				}
			}
		}

		// Normalizing label values
		for (int i = 0; i < labels.rows; ++i) {
			for (int j = 0; j < labels.cols; ++j) {
				uchar label = labels.at<uchar>(i, j);
				if (label > maxLabel)
					maxLabel = label;
			}
		}
		Mat normalizedLabels = labels * (255 / maxLabel);
		imshow("NormalizedLabeledImage", normalizedLabels);


		// Creating black labels on white background
		Mat blackLabelsOnWhite(image.rows, image.cols, CV_8UC3, Scalar(255, 255, 255));
		for (int i = 0; i < image.rows; i++) {
			for (int j = 0; j < image.cols; j++) {
				if (normalizedLabels.at<uchar>(i, j) != 0)
					blackLabelsOnWhite.at<Vec3b>(i, j) = Vec3b(0, 0, 0);
			}
		}
		imshow("BlackLabelsOnWhite", blackLabelsOnWhite);

		// Colouring the labels
		for (int k = 1; k <= label; k++) {
			uchar red = d(gen);
			uchar blue = d(gen);
			uchar green = d(gen);
			Vec3b color = Vec3b(blue, green, red);
			for (int i = 1; i < image.rows - 1; i++) {
				for (int j = 1; j < image.cols - 1; j++) {
					if (labels.at<uchar>(i, j) == k)
						show.at<Vec3b>(i, j) = color;
				}
			}
		}
		imshow("ColoredImage", show);
		waitKey(0);
	}
}

void processOfLabeling()
{
	int di[8] = { -1, -1, -1, 0, 0, 1, 1, 1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	uchar val, label = 0;
	Vec3b color;
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat image = imread(fname, IMREAD_GRAYSCALE);
		Mat labels = Mat::zeros(image.rows, image.cols, CV_8UC1);
		Mat show(image.rows, image.cols, CV_8UC3, Scalar(255, 255, 255));

		// Show original image
		imshow("Original Image", image);
		waitKey(1000);

		for (int i = 1; i < image.rows - 1; i++) {
			for (int j = 1; j < image.cols - 1; j++) {
				val = image.at<uchar>(i, j);
				if ((val == 0) && (labels.at<uchar>(i, j) == 0)) {
					label++;
					std::queue<Point> Q;
					labels.at<uchar>(i, j) = label;
					Q.push({ i,j });

					while (!Q.empty()) {
						Point q = Q.front();
						Q.pop();
						for (int k = 0; k < 8; k++) {
							if ((image.at<uchar>(q.x + di[k], q.y + dj[k]) == 0) && (labels.at<uchar>(q.x + di[k], q.y + dj[k]) == 0)) {
								labels.at<uchar>(q.x + di[k], q.y + dj[k]) = label;
								Q.push({ q.x + di[k], q.y + dj[k] });
							}
						}

						// Update labeled image and show
						show.setTo(Scalar(255, 255, 255));  // Reset show to white
						for (int r = 0; r < labels.rows; ++r) {
							for (int c = 0; c < labels.cols; ++c) {
								if (labels.at<uchar>(r, c) != 0) {
									Vec3b color = Vec3b(0, 0, 0);  // Black color for label
									show.at<Vec3b>(r, c) = color;
								}
							}
						}
						imshow("Labeled Image", show);
						waitKey(10);  // Delay between frames
					}
				}
			}
		}
	}
}

void borderTracing() {

	Mat image;

	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		image = imread(fname, 0);

		Mat	borderImage(image.rows, image.cols, CV_8UC1, Scalar(255));

		Point p1, p2, p3, p4;

		int dir = 7;
		int derivativeDirValue;

		int dj[8] = { 1, 1, 0,-1, -1, -1, 0, 1 };
		int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };

		bool stop = false;

		std::vector<Point> border;

		for (int i = 1; i < image.rows; i++) {
			for (int j = 1; j < image.cols - 1; j++) {
				if (image.at<uchar>(i, j) == 0) {
					p1.x = i;
					p1.y = j;
					stop = true;
					break;
				}
			}
			if (stop == true)
				break;
		}

		for (int k = 0; k < 8; k++) {
			int x = p1.x + di[(dir + 6) % 8];
			int y = p1.y + dj[(dir + 6) % 8];
			if (image.at<uchar>(x, y) == 0) {
				p2.x = x;
				p2.y = y;
				break;
			}
			dir++;
		}
		dir = (dir + 6) % 8;

		border.push_back(p1);
		border.push_back(p2);

		p4 = p2;

		while (!((p3.x == p1.x) && (p3.y == p1.y) && (p4.x == p2.x) && (p4.y == p2.y))) {
			p3 = p4;
			if (dir % 2 != 1) {
				for (int k = 0; k < 8; k++) {
					int x = p3.x + di[(dir + 7) % 8];
					int y = p3.y + dj[(dir + 7) % 8];
					if (image.at<uchar>(x, y) == 0) {
						p4.x = x;
						p4.y = y;
						break;
					}
					dir++;
				}
				dir = (dir + 7) % 8;
			}
			else {
				for (int k = 0; k < 8; k++) {
					int x = p3.x + di[(dir + 6) % 8];
					int y = p3.y + dj[(dir + 6) % 8];
					if (image.at<uchar>(x, y) == 0) {
						p4.x = x;
						p4.y = y;
						break;
					}
					dir++;
				}
				dir = (dir + 6) % 8;
			}
			border.push_back(p4);
		}

		for (int i = 0; i < border.size(); i++) {
			borderImage.at<uchar>(border[i].x, border[i].y) = 0;
		}
		imshow("borderImage", borderImage);
		waitKey(0);
	}
}

void chainCodeDer() {
	Mat image;
	char fname[MAX_PATH];
	while (openFileDlg(fname))
	{
		image = imread(fname, 0);

		Point p1, p2, p3, p4;

		int dir = 7;
		int dj[8] = { 1, 1, 0,-1, -1, -1, 0, 1 };
		int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };

		bool stop = false;

		std::vector<int> dirs;

		for (int i = 1; i < image.rows; i++) {
			for (int j = 1; j < image.cols - 1; j++) {
				if (image.at<uchar>(i, j) == 0) {
					p1.x = i;
					p1.y = j;
					stop = true;
					break;
				}
			}
			if (stop == true)
				break;
		}

		for (int k = 0; k < 8; k++) {
			int x = p1.x + di[(dir + 6) % 8];
			int y = p1.y + dj[(dir + 6) % 8];
			if (image.at<uchar>(x, y) == 0) {
				p2.x = x;
				p2.y = y;
				break;
			}
			dir++;
		}

		dir = (dir + 6) % 8;

		dirs.push_back(dir);

		p4 = p2;

		while (!((p3.x == p1.x) && (p3.y == p1.y) && (p4.x == p2.x) && (p4.y == p2.y))) {
			p3 = p4;
			if (dir % 2 != 1) {
				for (int k = 0; k < 8; k++) {
					int x = p3.x + di[(dir + 7) % 8];
					int y = p3.y + dj[(dir + 7) % 8];
					if (image.at<uchar>(x, y) == 0) {
						p4.x = x;
						p4.y = y;
						break;
					}
					dir++;
				}
				dir = (dir + 7) % 8;
			}
			else {
				for (int k = 0; k < 8; k++) {
					int x = p3.x + di[(dir + 6) % 8];
					int y = p3.y + dj[(dir + 6) % 8];
					if (image.at<uchar>(x, y) == 0) {
						p4.x = x;
						p4.y = y;
						break;
					}
					dir++;
				}
				dir = (dir + 6) % 8;
			}
			dirs.push_back(dir);
		}
		printf("Dirs: ");
		for (int i = 0; i < dirs.size() - 2; i++) {
			printf("%d ", dirs[i]);
		}

		printf("\nDerivative: ");

		for (int i = 1; i < dirs.size() - 2; i++) {
			printf("%d ", (8 + dirs[i] - dirs[i - 1]) % 8);
		}

		printf("%d", (8 + dirs[0] - dirs[dirs.size() - 3]) % 8);

		waitKey(20000);
	}
}

void reconstruct() {

	std::string filename("C:\\Users\\imred\\Desktop\\OpenCVApplication-VS2022_OCV490_basic\\files_border_tracing\\reconstruct.txt");
	Mat src;
	char fname[MAX_PATH];

	while (openFileDlg(fname))
	{
		src = imread(fname, 0);
		imshow("border", src);

		int x, y, nr;
		int dir;

		int dj[8] = { 1, 1, 0,-1, -1, -1, 0, 1 };
		int di[8] = { 0, -1, -1, -1, 0, 1, 1, 1 };


		std::ifstream input_file(filename);

		input_file >> x >> y >> nr;
		src.at<uchar>(x, y) = 0;

		while (input_file >> dir) {
			x = x + di[dir];
			y = y + dj[dir];
			src.at<uchar>(x, y) = 0;
		}

		imshow("border", src);
		waitKey(0);

	}
}
void dilation() {
	uchar val;
	int di[8] = { -1,-1,-1, 0, 0, 1,1,1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		Mat afis(img.rows, img.cols, CV_8UC1, Scalar(255));
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				val = img.at<uchar>(i, j);
				if (val == 0) {
					for (int k = 0; k < 8; k++) {
						afis.at<uchar>(i + di[k], j + dj[k]) = 0;
					}
				}
			}
		}
		imshow("dilation", afis);
		imshow("original", img);
		waitKey(0);
	}
}

void erosion() {
	uchar val;
	int di[8] = { -1,-1,-1, 0, 0, 1,1,1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		Mat afis(img.rows, img.cols, CV_8UC1);
		afis = img.clone();
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				val = img.at<uchar>(i, j);
				if (val == 255) {
					for (int k = 0; k < 8; k++) {
						afis.at<uchar>(i + di[k], j + dj[k]) = 255;
					}
				}
			}
		}
		imshow("erosion", afis);
		imshow("original", img);
		waitKey(0);
	}
}

void opening() {
	uchar val;
	int di[8] = { -1,-1,-1, 0, 0, 1,1,1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		imshow("original", img);
		Mat afis(img.rows, img.cols, CV_8UC1);
		Mat afis2(img.rows, img.cols, CV_8UC1);
		afis = img.clone();
		//eroziune();
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				val = img.at<uchar>(i, j);
				if (val == 255) {
					for (int k = 0; k < 8; k++) {
						afis.at<uchar>(i + di[k], j + dj[k]) = 255;
					}
				}
			}
		}
		afis2 = afis.clone();

		imshow("deschidere", afis);
		waitKey(2000);
		//dilatare();
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				val = afis.at<uchar>(i, j);
				if (val == 0) {
					for (int k = 0; k < 8; k++) {
						afis2.at<uchar>(i + di[k], j + dj[k]) = 0;
					}
				}
			}
		}
		imshow("opening", afis2);
		waitKey(0);
	}
}

void closing() {
	uchar val;
	int di[8] = { -1,-1,-1, 0, 0, 1,1,1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		imshow("original", img);
		Mat afis(img.rows, img.cols, CV_8UC1);
		Mat afis2(img.rows, img.cols, CV_8UC1);
		afis = img.clone();
		//dilation();
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				val = img.at<uchar>(i, j);
				if (val == 0) {
					for (int k = 0; k < 8; k++) {
						afis.at<uchar>(i + di[k], j + dj[k]) = 0;
					}
				}
			}
		}
		afis2 = afis.clone();
		imshow("closing", afis);
		waitKey(2000);

		//erosion();
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				val = afis.at<uchar>(i, j);
				if (val == 255) {
					for (int k = 0; k < 8; k++) {
						afis2.at<uchar>(i + di[k], j + dj[k]) = 255;
					}
				}
			}
		}

		imshow("closing", afis2);
		waitKey(0);
	}
}

void dilation_n() {
	int n = 1;
	printf("introduce n: ");
	scanf("%d", &n);
	uchar val;
	int di[8] = { -1,-1,-1, 0, 0, 1,1,1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		imshow("dilation", img);
		Mat afis(img.rows, img.cols, CV_8UC1, Scalar(255));
		Mat afis2(img.rows, img.cols, CV_8UC1, Scalar(255));
		afis2 = img.clone();
		afis = img.clone();
		for (int z = 0; z < n; z++) {
			for (int i = 1; i < img.rows - 1; i++) {
				for (int j = 1; j < img.cols - 1; j++) {
					val = afis2.at<uchar>(i, j);
					if (val == 0) {
						for (int k = 0; k < 8; k++) {
							afis.at<uchar>(i + di[k], j + dj[k]) = 0;
						}
					}
				}
			}
			imshow("dilation", afis);
			waitKey(200);
			afis2 = afis.clone();
		}
		imshow("dilation", afis);

		waitKey(0);
	}
}

void erosion_n() {
	int n = 1;
	printf("Introduce n: ");
	scanf("%d", &n);
	uchar val;
	int di[8] = { -1,-1,-1, 0, 0, 1,1,1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		imshow("erosion", img);
		Mat afis(img.rows, img.cols, CV_8UC1);
		Mat afis2(img.rows, img.cols, CV_8UC1);
		afis2 = img.clone();
		afis = img.clone();
		for (int z = 0; z < n; z++) {
			for (int i = 1; i < img.rows - 1; i++) {
				for (int j = 1; j < img.cols - 1; j++) {
					val = afis2.at<uchar>(i, j);
					if (val == 255) {
						for (int k = 0; k < 8; k++) {
							afis.at<uchar>(i + di[k], j + dj[k]) = 255;
						}
					}
				}
			}
			imshow("erosion", afis);
			waitKey(200);
			afis2 = afis.clone();
		}
		waitKey(0);
	}
}


void opening_n() {
	int n = 1;
	printf("Introduce n: ");
	scanf("%d", &n);
	uchar val;
	int di[8] = { -1,-1,-1, 0, 0, 1,1,1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		imshow("opening_n", img);
		Mat afis(img.rows, img.cols, CV_8UC1);
		Mat afis2(img.rows, img.cols, CV_8UC1);
		afis = img.clone();
		afis2 = img.clone();
		//erosion();
		for (int z = 0; z < n; z++) {
			for (int i = 1; i < img.rows - 1; i++) {
				for (int j = 1; j < img.cols - 1; j++) {
					val = afis2.at<uchar>(i, j);
					if (val == 255) {
						for (int k = 0; k < 8; k++) {
							afis.at<uchar>(i + di[k], j + dj[k]) = 255;
						}
					}
				}

			}
			afis2 = afis.clone();
			imshow("opening_n", afis);
			waitKey(200);
			//dilation();
			for (int i = 1; i < img.rows - 1; i++) {
				for (int j = 1; j < img.cols - 1; j++) {
					val = afis2.at<uchar>(i, j);
					if (val == 0) {
						for (int k = 0; k < 8; k++) {
							afis.at<uchar>(i + di[k], j + dj[k]) = 0;
						}
					}
				}

			}
			imshow("opening_n", afis);
			waitKey(200);
			afis2 = afis.clone();
		}
		imshow("opening_n", afis);
		waitKey(0);
	}
}

void closing_n() {
	int n = 1;
	printf("Introduce n: ");
	scanf("%d", &n);
	uchar val;
	int di[8] = { -1,-1,-1, 0, 0, 1,1,1 };
	int dj[8] = { -1, 0, 1, -1, 1, -1, 0, 1 };
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		imshow("closing_n", img);
		Mat afis(img.rows, img.cols, CV_8UC1);
		Mat afis2(img.rows, img.cols, CV_8UC1);
		afis = img.clone();
		afis2 = img.clone();
		//dilation();
		for (int z = 0; z < n; z++) {
			for (int i = 1; i < img.rows - 1; i++) {
				for (int j = 1; j < img.cols - 1; j++) {
					val = afis2.at<uchar>(i, j);
					if (val == 0) {
						for (int k = 0; k < 8; k++) {
							afis.at<uchar>(i + di[k], j + dj[k]) = 0;
						}
					}
				}
			}
			afis2 = afis.clone();
			imshow("closing_n", afis);
			waitKey(200);

			//erosion();
			for (int i = 1; i < img.rows - 1; i++) {
				for (int j = 1; j < img.cols - 1; j++) {
					val = afis2.at<uchar>(i, j);
					if (val == 255) {
						for (int k = 0; k < 8; k++) {
							afis.at<uchar>(i + di[k], j + dj[k]) = 255;
						}
					}
				}
			}
			afis2 = afis.clone();
			imshow("closing_n", afis);
			waitKey(200);
		}

		imshow("closing_n", afis);
		waitKey(0);
	}
}

void infoHistogram() {
	float deviation = 0, medium = 0, pixels = 0, pixels2 = 0;
	int hist[256] = {}, histCumul[256] = {};
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				pixels += img.at<uchar>(i, j);
			}
		}
		medium = pixels / (img.rows * img.cols);
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				pixels2 += pow(img.at<uchar>(i, j) - medium, 2);
			}
		}
		printf("%f\n", medium);
		medium = pixels2 / (img.rows * img.cols);
		deviation = sqrt(medium);
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				hist[img.at<uchar>(i, j)]++;
			}
		}
		printf("%f\n", deviation);
		for (int i = 0; i <= 255; i++) {
			for (int j = 0; j <= i; j++) {
				histCumul[i] += hist[j];
			}
		}
		showHistogram("histogram", hist, 256, 256);
		showHistogram("histogramCum", histCumul, 256, 256);
		waitKey();
	}

}
void Binarization() {
	float deviation = 0, medium1 = 0, medium2 = 0, pixels = 0, pixels2 = 0, T = 0, T2 = 0;
	int min = 256, max = 0, N1 = 0, N2 = 0;
	int hist[256] = {}, histCumul[256] = {};
	char fname[MAX_PATH];
	while (openFileDlg(fname)) {
		Mat img = imread(fname, IMREAD_GRAYSCALE);
		for (int i = 1; i < img.rows - 1; i++) {
			for (int j = 1; j < img.cols - 1; j++) {
				hist[img.at<uchar>(i, j)]++;
				if (img.at<uchar>(i, j) < min)
					min = img.at<uchar>(i, j);
				if (img.at<uchar>(i, j) > max)
					max = img.at<uchar>(i, j);
			}
		}
		T = (min + max) / 2;

		while (abs(T - T2) >= 0.1) {

			T2 = T;

			medium1 = 0;
			medium2 = 0;
			N1 = 0;
			N2 = 0;

			for (int i = min; i < T; i++) {
				medium1 += i * hist[i];
				N1 += hist[i];
			}
			for (int i = T + 1; i <= max; i++) {
				medium2 += i * hist[i];
				N2 += hist[i];
			}
			medium1 /= N1;
			medium2 /= N2;


			T = (medium1 + medium2) / 2;
		}
		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				if (img.at<uchar>(i, j) <= T)
					img.at<uchar>(i, j) = 0;
				else
					img.at<uchar>(i, j) = 255;
			}
		}

		imshow("Binarization", img);
		waitKey();
	}
}

void EqualHistogram() {
	Mat img;
	char fname[MAX_PATH];
	int hist[256] = {};
	int pc[256] = {};
	while (openFileDlg(fname)) {

		img = imread(fname, 0);
		imshow("Source image", img);

		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				hist[img.at<uchar>(i, j)]++;
			}
		}

		int M = img.rows * img.cols;



		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				float index = 0;
				for (int k = 0; k <= img.at<uchar>(i, j); k++)
					index += hist[k] / (float)M;
				index = index * 255;

				img.at<uchar>(i, j) = (int)index;
			}
		}

		for (int i = 0; i < img.rows; i++) {
			for (int j = 0; j < img.cols; j++) {
				pc[img.at<uchar>(i, j)]++;
			}
		}

		showHistogram("Histogram", hist, 256, 256);
		showHistogram("Equalized Histogram", pc, 256, 256);

		imshow("Destination Image", img);
	}
}

void histogram_transformations() {

	Mat src;
	char fname[MAX_PATH];
	int hist[256] = {};
	int negativeHist[256] = {};
	int intensityHist[256] = {};
	int contrastHist[256] = {};
	int gammaHist[256] = {};
	int offset;
	int imin = 255;
	int imax = 0;
	int gmin, gmax;
	float gamma;

	while (openFileDlg(fname))
	{
		src = imread(fname, 0);
		imshow("originalImage", src);

		for (int i = 0; i < src.rows; i++) {
			for (int j = 0; j < src.cols; j++) {
				uchar pixelColor = src.at<uchar>(i, j);
				if (imin > pixelColor)
					imin = pixelColor;
				if (imax < pixelColor)
					imax = pixelColor;

				hist[pixelColor]++;
			}
		}


		for (int i = 0; i < 256; i++) {
			negativeHist[i] = hist[255 - i];
		}


		printf("insert offset:");
		scanf("%d", &offset);

		for (int i = 0; i < 256; i++) {
			if ((i + offset > 255) || (i + offset < 0))
				intensityHist[i] = 0;
			else
				intensityHist[i] = hist[i + offset];
		}


		printf("insert new contrast interval: ");
		scanf("%d %d", &gmin, &gmax);

		for (int i = 0; i < 256; i++) {
			int index;
			index = gmin + (i - imin) * ((gmax - gmin) / (float)(imax - imin));
			//printf("%f\n", (i - imin) * ((gmax - gmin) / (float)(imax - imin)));
			if ((index >= 0) && (index < 256))
				contrastHist[index] = hist[i];
		}

		printf("insert gamma correction: ");
		scanf("%f", &gamma);


		for (int i = 0; i < 256; i++) {
			int index;
			index = 255 * pow((i / 255.0), gamma);

			if ((index >= 0) && (index < 256))
				gammaHist[index] = hist[i];
		}


		/*for (int i = 0; i < src.rows; i++) {
			for (int j = 0; j < src.cols; j++) {
				int val;
				val = 255 * pow((src.at<uchar>(i, j) / 255.0), gamma);
				if (val < 0)
					val = 0;

				if (val > 255)
					val = 255;
				src.at<uchar>(i, j) = val;
			}
		}

		for (int i = 0; i < src.rows; i++) {
			for (int j = 0; j < src.cols; j++) {
				uchar pixelColor = src.at<uchar>(i, j);
				gammaHist[pixelColor]++;
			}
		}*/

		showHistogram("OriginalHistogram", hist, 256, 256);
		showHistogram("NegativeHistogram", negativeHist, 256, 256);
		showHistogram("IntensityHistogram", intensityHist, 256, 256);
		showHistogram("ContrstHistogram", contrastHist, 256, 256);
		showHistogram("GammaCorrectionHistogram", gammaHist, 256, 256);

		//imshow("Gamma Image", src);
	}
}

void arithmeticFilter() {
	Mat src;
	int filter[3][3] = { 1,1,1,1,1,1,1,1,1 };
	char fname[MAX_PATH];
	float scalar = 9;
	while (openFileDlg(fname)) {

		src = imread(fname, 0);
		imshow("originalImage", src);
		Mat result = src.clone();

		for (int i = 1; i < src.rows - 1; i++) {
			for (int j = 1; j < src.cols - 1; j++) {
				int pixelVal = 0;

				for (int u = 0; u < 3; u++) {
					for (int v = 0; v < 3; v++) {
						pixelVal += filter[u][v] * src.at<uchar>(i + u - 1, j + v - 1);
					}
				}
				result.at<uchar>(i, j) = pixelVal / scalar;

			}
		}

		imshow("Filtered result", result);
		waitKey(0);
	}
}

void gaussianFilter() {
	Mat src;
	int filter[3][3] = { 1,2,1,2,4,2,1,2,1 };
	char fname[MAX_PATH];
	float scalar = 16;
	while (openFileDlg(fname)) {

		src = imread(fname, 0);
		imshow("originalImage", src);
		Mat result = src.clone();

		for (int i = 1; i < src.rows - 1; i++) {
			for (int j = 1; j < src.cols - 1; j++) {
				int pixelVal = 0;

				for (int u = 0; u < 3; u++) {
					for (int v = 0; v < 3; v++) {
						pixelVal += filter[u][v] * src.at<uchar>(i + u - 1, j + v - 1);
					}
				}
				result.at<uchar>(i, j) = pixelVal / scalar;

			}
		}

		imshow("Filtered result", result);
		waitKey(0);
	}
}



void laPlaceFilter() {
	Mat src;
	int filter[3][3] = { 0,-1,0,-1,4,-1,0,-1,0 };
	char fname[MAX_PATH];
	int s1 = 0, s2 = 0;
	float scalar = 0;
	while (openFileDlg(fname)) {

		src = imread(fname, 0);
		imshow("originalImage", src);
		Mat result = src.clone();

		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				if (filter[i][j] < 0)
					s1 += abs(filter[i][j]);
				else
					s2 += filter[i][j];
			}
		}
		scalar = 2 * max(s1, s2);

		for (int i = 1; i < src.rows - 1; i++) {
			for (int j = 1; j < src.cols - 1; j++) {
				int pixelVal = 0;

				for (int u = 0; u < 3; u++) {
					for (int v = 0; v < 3; v++) {
						pixelVal += filter[u][v] * src.at<uchar>(i + u - 1, j + v - 1);
					}
				}
				result.at<uchar>(i, j) = pixelVal / scalar + 255 / 2;

			}
		}


		imshow("Filtered result", result);
		waitKey(0);
	}
}

void highPassFilter() {
	Mat src;
	int filter[3][3] = { 0,-1,0,-1,5,-1,0,-1,0 };
	char fname[MAX_PATH];
	int s1 = 0, s2 = 0;
	float scalar = 0;
	while (openFileDlg(fname)) {

		src = imread(fname, 0);
		imshow("originalImage", src);
		Mat result = src.clone();

		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				if (filter[i][j] < 0)
					s1 += abs(filter[i][j]);
				else
					s2 += filter[i][j];
			}
		}
		scalar = 2 * max(s1, s2);

		for (int i = 1; i < src.rows - 1; i++) {
			for (int j = 1; j < src.cols - 1; j++) {
				int pixelVal = 0;

				for (int u = 0; u < 3; u++) {
					for (int v = 0; v < 3; v++) {
						pixelVal += filter[u][v] * src.at<uchar>(i + u - 1, j + v - 1);
					}
				}
				result.at<uchar>(i, j) = pixelVal / scalar + 255 / 2;

			}
		}


		imshow("Filtered result", result);
		waitKey(0);
	}
}

void centering_transform(Mat img) {
	for (int i = 0; i < img.rows; i++) {
		for (int j = 0; j < img.cols; j++) {
			img.at<float>(i, j) = ((i + j) & 1) ? -img.at<float>(i, j) : img.at<float>(i, j);
		}
	}
}


void medianFilter() {
	Mat src;
	Mat final;

	char fname[MAX_PATH];

	while (openFileDlg(fname)) {

		src = imread(fname, 0);
		imshow("image", src);

		int w;

		final = src.clone();

		printf("length:");
		scanf("%d", &w);
		double t = (double)getTickCount();

		for (int i = 0; i < src.rows - w; i++) {
			for (int j = 0; j < src.cols - w; j++) {
				std::vector<int> values;
				for (int x = 0; x < w; x++) {
					for (int y = 0; y < w; y++) {
						values.push_back(src.at<uchar>(i + x, j + y));
					}
				}
				sort(values.begin(), values.end());
				final.at<uchar>(i + w / 2, j + w / 2) = values.at(pow(w, 2) / 2);
			}
		}
		t = ((double)getTickCount() - t) / getTickFrequency();
		printf("Time = %.3f [ms] \n", t * 1000);
		imshow("finalImage", final);
		waitKey();
	}
}

void gaussianFilter2() {
	Mat src;
	Mat final;

	char fname[MAX_PATH];

	while (openFileDlg(fname)) {
		src = imread(fname, 0);
		imshow("originalImage", src);

		final = src.clone();

		int w = 0;
		printf("another value:");
		scanf("%d", &w);
		double t = (double)getTickCount();

		float convolutionNucleus[200][200];
		float row = (float)w / 6;
		int mid = w / 2;

		for (int i = 0; i < w; i++) {
			for (int j = 0; j < w; j++) {

				convolutionNucleus[i][j] = (1.0 / (2 * 3.14 * pow(row, 2))) * exp(-(float)(pow((i - mid), 2) + pow((j - mid), 2)) / (2.0 * pow(row, 2)));

			}
		}

		/*for (int i = 0; i < w; i++) {
			for (int j = 0; j < w; j++) {
				std::cout << convolutionNucleus[i][j] << " ";
			}
			std::cout << std::endl;
		}*/

		for (int i = w / 2; i < src.rows - w / 2; i++) {
			for (int j = w / 2; j < src.cols - w / 2; j++) {

				float value = 0;

				for (int u = 0; u < w; u++) {
					for (int v = 0; v < w; v++) {
						value = value + convolutionNucleus[u][v] * src.at<uchar>(i + u - w / 2, j + v - w / 2);
					}
				}
				final.at<uchar>(i, j) = (char)(value);

			}
		}
		t = ((double)getTickCount() - t) / getTickFrequency();
		printf("Time = %.3f [ms] \n", t * 1000);
		imshow("finalImg", final);
		waitKey();

	}

}

Mat sablon2(Mat src) {
	Mat srcf(src.rows, src.cols, CV_32FC1);
	src.convertTo(srcf, CV_32FC1);

	centering_transform(srcf);

	Mat fourier;
	dft(srcf, fourier, DFT_COMPLEX_OUTPUT);


	Mat channels[] = { Mat::zeros(src.size(),CV_32F),Mat::zeros(src.size(),CV_32F) };
	split(fourier, channels);



	Mat mag;
	magnitude(channels[0], channels[1], mag);
	mag += Scalar::all(1);
	log(mag, mag);

	normalize(mag, mag, 0, 1, NORM_MINMAX);

	imshow("Magnitude", mag);


	Mat dst, dstf;
	merge(channels, 2, fourier);
	dft(fourier, dstf, DFT_INVERSE | DFT_REAL_OUTPUT | DFT_SCALE);


	centering_transform(dstf);
	normalize(dstf, dst, 0, 255, NORM_MINMAX, CV_8UC1);

	imshow("initial", src);
	imshow("final", dst);
	waitKey();

	return dst;
}

void Magnitude() {
	Mat src;
	Mat result;
	char fname[MAX_PATH];

	while (openFileDlg(fname)) {

		src = imread(fname, 0);
		result = sablon2(src);
		waitKey(0);

	}
}


Mat sablon6(Mat src) {
	Mat srcf(src.rows, src.cols, CV_32FC1);
	src.convertTo(srcf, CV_32FC1);

	centering_transform(srcf);

	Mat fourier;
	dft(srcf, fourier, DFT_COMPLEX_OUTPUT);

	Mat channels[] = { Mat::zeros(src.size(),CV_32F),Mat::zeros(src.size(),CV_32F) };
	split(fourier, channels);



	Mat mag;
	magnitude(channels[0], channels[1], mag);
	mag += Scalar::all(1);
	log(mag, mag);

	normalize(mag, mag, 0, 1, NORM_MINMAX);

	for (int i = 0; i < fourier.rows; i++) {
		for (int j = 0; j < fourier.cols; j++) {
			float val = 0;
			val = (pow(fourier.rows / 2 - i, 2) + pow(fourier.cols / 2 - j, 2)) / pow(20, 2);
			val = -val;
			channels[0].at<float>(i, j) *= 1 - exp(val);
			channels[1].at<float>(i, j) *= 1 - exp(val);
		}
	}



	Mat dst, dstf;
	merge(channels, 2, fourier);
	dft(fourier, dstf, DFT_INVERSE | DFT_REAL_OUTPUT | DFT_SCALE);

	centering_transform(dstf);
	normalize(dstf, dst, 0, 255, NORM_MINMAX, CV_8UC1);

	imshow("initial", src);
	imshow("final", dst);
	waitKey();

	return dst;
}

void GaussianHighPass() {
	Mat src;
	Mat result;
	char fname[MAX_PATH];

	while (openFileDlg(fname)) {

		src = imread(fname, 0);
		result = sablon6(src);
		waitKey(0);

	}
}

Mat sablon3(Mat src) {
	Mat srcf(src.rows, src.cols, CV_32FC1); 
	src.convertTo(srcf, CV_32FC1);

	centering_transform(srcf); 

	Mat fourier; 
	dft(srcf, fourier, DFT_COMPLEX_OUTPUT); 

	
	Mat channels[] = { Mat::zeros(src.size(),CV_32F),Mat::zeros(src.size(),CV_32F) };
	split(fourier, channels);
	

	Mat mag;
	magnitude(channels[0], channels[1], mag);
	mag += Scalar::all(1);
	log(mag, mag);

	normalize(mag, mag, 0, 1, NORM_MINMAX);

	for (int i = 0; i < fourier.rows; i++) {
		for (int j = 0; j < fourier.cols; j++) {
			float val = 0;
			val = pow(fourier.rows / 2 - i, 2) + pow(fourier.cols / 2 - j, 2);
			if (val > pow(20, 2)) {
				channels[0].at<float>(i, j) = 0;
				channels[1].at<float>(i, j) = 0;
			}
		}
	}


	

	Mat dst, dstf;
	merge(channels, 2, fourier); 
	dft(fourier, dstf, DFT_INVERSE | DFT_REAL_OUTPUT | DFT_SCALE); 


	centering_transform(dstf); 
	normalize(dstf, dst, 0, 255, NORM_MINMAX, CV_8UC1); 

	imshow("initial", src);
	imshow("final", dst);
	waitKey();

	return dst;
}

void idealLowPass() {
	Mat src;
	Mat result;
	char fname[MAX_PATH];

	while (openFileDlg(fname)) {

		src = imread(fname, 0);
		result = sablon3(src);
		waitKey(0);

	}
}

void gradient() {
	Mat src;

	char fname[MAX_PATH];

	while (openFileDlg(fname)) {
		src = imread(fname, 0);
		imshow("originalImage", src);

		GaussianBlur(src, src, Size(3, 3), 0.5, 0.5);

		Mat fx = Mat(src.rows, src.cols, CV_32SC1, Scalar(0));
		Mat fy = Mat(src.rows, src.cols, CV_32SC1, Scalar(0));
		Mat module = Mat(src.rows, src.cols, CV_8UC1, Scalar(0));
		Mat direction = Mat(src.rows, src.cols, CV_32F, Scalar(0.0));

		int filterx[3][3] = { -1, 0, 1,-2, 0, 2,-1, 0, 1 };
		int filtery[3][3] = { 1, 2, 1, 0, 0, 0, -1,-2, -1 };

		for (int i = 1; i < src.rows - 1; i++) {
			for (int j = 1; j < src.cols - 1; j++) {
				int pixelValx = 0;
				int pixelValy = 0;

				for (int u = 0; u < 3; u++) {
					for (int v = 0; v < 3; v++) {
						pixelValx += filterx[u][v] * src.at<uchar>(i + u - 1, j + v - 1);
						pixelValy += filtery[u][v] * src.at<uchar>(i + u - 1, j + v - 1);

					}
				}
				fx.at<int>(i, j) = pixelValx;
				fy.at<int>(i, j) = pixelValy;

			}
		}

		for (int i = 1; i < src.rows - 1; i++) {
			for (int j = 1; j < src.cols - 1; j++) {
				module.at<uchar>(i, j) = sqrt(pow(fx.at<int>(i, j), 2) + pow(fy.at<int>(i, j), 2)) / (4.0 * sqrt(2));
				direction.at<float>(i, j) = (atan2(fy.at<int>(i, j), fx.at<int>(i, j)) + CV_PI);
			}
		}
		/*for (int i = 1; i < src.rows - 1; i++) {
			for (int j = 1; j < src.cols - 1; j++) {
				printf("%d ", (int)direction.at<uchar>(i, j));
			}
		}*/

		Mat module_cln = module.clone();

		float ls11 = CV_PI / 8;
		float ld11 = 3 * CV_PI / 8;

		float ls12 = 9 * CV_PI / 8;
		float ld12 = 11 * CV_PI / 8;


		float ls01 = 3 * CV_PI / 8;
		float ld01 = 5 * CV_PI / 8;

		float ls02 = 11 * CV_PI / 8;
		float ld02 = 13 * CV_PI / 8;


		float ls31 = 5 * CV_PI / 8;
		float ld31 = 7 * CV_PI / 8;

		float ls32 = 13 * CV_PI / 8;
		float ld32 = 15 * CV_PI / 8;


		float ls21 = 7 * CV_PI / 8;
		float ld21 = 9 * CV_PI / 8;

		float ls22 = 15 * CV_PI / 8;
		float ld22 = 1 * CV_PI / 8;



		for (int i = 1; i < src.rows - 1; i++) {
			for (int j = 1; j < src.cols - 1; j++) {

				if (((direction.at<float>(i, j) > ls11) && (direction.at<float>(i, j) <= ld11)) ||
					((direction.at<float>(i, j) > ls12) && (direction.at<float>(i, j) <= ld12))) {

					if (module_cln.at<uchar>(i - 1, j + 1) >= module_cln.at<uchar>(i, j) ||
						module_cln.at<uchar>(i + 1, j - 1) >= module_cln.at<uchar>(i, j))
						module_cln.at<uchar>(i, j) = 0;
				}

				if (((direction.at<float>(i, j) > ls01) && (direction.at<float>(i, j) <= ld01)) ||
					((direction.at<float>(i, j) > ls02) && (direction.at<float>(i, j) <= ld02))) {

					if (module_cln.at<uchar>(i - 1, j) >= module_cln.at<uchar>(i, j) ||
						module_cln.at<uchar>(i + 1, j) >= module_cln.at<uchar>(i, j))
						module_cln.at<uchar>(i, j) = 0;
				}

				if (((direction.at<float>(i, j) > ls31) && (direction.at<float>(i, j) <= ld31)) ||
					((direction.at<float>(i, j) > ls32) && (direction.at<float>(i, j) <= ld32))) {

					if (module_cln.at<uchar>(i - 1, j - 1) >= module_cln.at<uchar>(i, j) ||
						module_cln.at<uchar>(i + 1, j + 1) >= module_cln.at<uchar>(i, j))
						module_cln.at<uchar>(i, j) = 0;
				}

				if (((direction.at<float>(i, j) > ls21) && (direction.at<float>(i, j) <= ld21)) ||
					((direction.at<float>(i, j) > ls22) && (direction.at<float>(i, j) <= ld22))) {

					if (module_cln.at<uchar>(i, j - 1) >= module_cln.at<uchar>(i, j) ||
						module_cln.at<uchar>(i, j + 1) >= module_cln.at<uchar>(i, j))
						module_cln.at<uchar>(i, j) = 0;
				}

			}
		}

		imshow("module", module);

		imshow("module_clone", module_cln);

		int zeroGradientModulePixels = 0;
		float p = 0.1;

		for (int i = 1; i < module.rows - 1; i++) {
			for (int j = 1; j < module.cols - 1; j++) {
				if (module_cln.at<uchar>(i, j) == 0) {
					zeroGradientModulePixels++;
				}
			}
		}

		int numberEdgePixels = p * ((module.rows - 2) * (module.cols - 2) - zeroGradientModulePixels);
		int numberNonEdgePixels = (1 - p) * ((module.rows - 2) * (module.cols - 2) - zeroGradientModulePixels);

		int histogram[256] = {};

		for (int i = 1; i < module.rows - 1; i++) {
			for (int j = 1; j < module.cols - 1; j++) {
				histogram[module_cln.at<uchar>(i, j)]++;
			}
		}
		int s = 0;
		int index;
		for (index = 1; index < 256; index++) {

			s += histogram[index];
			if (s > numberNonEdgePixels)
				break;
		}
		int thHigh = index;

		int thLow = 0.4 * thHigh;

		for (int i = 0; i < module.rows; i++) {
			for (int j = 0; j < module.cols; j++) {
				int value = module_cln.at<uchar>(i, j);

				if (value < thLow)
					module_cln.at<uchar>(i, j) = 0;
				else if (value > thHigh)
					module_cln.at<uchar>(i, j) = 255;
				else
					module_cln.at<uchar>(i, j) = 128;
			}
		}

		imshow("module_thresholded", module_cln);

		Mat	labels(src.rows, src.cols, CV_8UC1);
		labels = Mat::zeros(src.rows, src.cols, CV_8UC1);

		int di[8] = { -1,0,1,0,-1,1,-1,1 };
		int dj[8] = { 0,-1,0,1,-1,1,1,-1 };

		for (int i = 0; i < src.rows; i++) {
			for (int j = 0; j < src.cols; j++) {
				if ((module_cln.at<uchar>(i, j) == 255) && (labels.at<uchar>(i, j) == 0)) {
					std::queue<Point> Q;
					labels.at<uchar>(i, j) = 1;
					Q.push({ i,j });
					while (!Q.empty()) {
						Point q = Q.front();
						Q.pop();

						for (int k = 0; k < 8; k++)
							if ((module_cln.at<uchar>(q.x + di[k], q.y + dj[k]) == 128)
								&& (labels.at<uchar>(q.x + di[k], q.y + dj[k]) == 0)) {
								module_cln.at<uchar>(q.x + di[k], q.y + dj[k]) = 255;
								labels.at<uchar>(q.x + di[k], q.y + dj[k]) = 1;
								Q.push({ q.x + di[k], q.y + dj[k] });
							}
					}
				}
			}
		}

		for (int i = 0; i < src.rows; i++) {
			for (int j = 0; j < src.cols; j++) {
				if (module_cln.at<uchar>(i, j) == 128)
					module_cln.at<uchar>(i, j) = 0;
			}
		}

		imshow("edges", module_cln);
		waitKey(0);
	}
}


// PROJECT: Image Warping
// -warp (perspective transformation)
// -morph(lena with cameraman)
// -swirl(based on offset and angle)
// -wave



void warping() {
	// load the image using file path
	cv::Mat image = cv::imread("Images/Lena_24bits.bmp");

	// defining source and destination points using float values
	std::vector<cv::Point2f> src_points = {
		cv::Point2f(0.0f, 0.0f), cv::Point2f(static_cast<float>(image.cols - 1), 0.0f),
		cv::Point2f(0.0f, static_cast<float>(image.rows - 1)),
		cv::Point2f(static_cast<float>(image.cols - 1), static_cast<float>(image.rows - 1))
	};
	std::vector<cv::Point2f> dst_points = {
		cv::Point2f(100.0f, 100.0f), cv::Point2f(static_cast<float>(image.cols - 100), 100.0f),
		cv::Point2f(0.0f, static_cast<float>(image.rows - 1)),
		cv::Point2f(static_cast<float>(image.cols - 1), static_cast<float>(image.rows - 1))
	};

	// calculating the perspective transformation matrix
	cv::Mat matrix = cv::getPerspectiveTransform(src_points, dst_points);

	// apply the perspective warp to the image using dimensions
	cv::Mat warped_image;
	cv::warpPerspective(image, warped_image, matrix, image.size());

	// display the original and warped images
	cv::imshow("Original Image", image);
	cv::imshow("Warped Image", warped_image);

	// wait for 0 to be pressed and then close the windows
	cv::waitKey(0);
	cv::destroyAllWindows();
}


void morphing() {
	// images paths in source and destination
	std::string source = "Images/Lena_24bits.bmp";
	std::string destination = "Images/cameraman.bmp";

	// reading images and resizing it
	cv::Mat image_source = cv::imread(source);
	cv::resize(image_source, image_source, cv::Size(300, 300));

	cv::Mat image_destination = cv::imread(destination);
	cv::resize(image_destination, image_destination, cv::Size(300, 300));

	// morphing in 100 steps
	for (int i = 0; i < 100; i++) {
		float percentage = static_cast<float>(i) / 100.0f;
		std::cout << percentage << std::endl;
		cv::Mat imgAdd;
		cv::addWeighted(image_source, 1.0f - percentage, image_destination, percentage, 0.0, imgAdd);
		cv::imshow("Morphed", imgAdd);
		cv::waitKey(100);
	}

	// waiting till 0 is pressed
	cv::waitKey(0);
	// closing all windows
	cv::destroyAllWindows();
}


void swirl() 
{
	// Load the image using file path
	std::string imagePath = "Images/Lena_24bits.bmp";
	cv::Mat image = cv::imread(imagePath);
	if (image.empty()) {
		std::cerr << "Could not open or find the image!" << std::endl;
		return;
	}

	// Create an output image
	cv::Mat swirled_image = image.clone();

	// Center of the image
	float centerX = image.cols / 2.0f;
	float centerY = image.rows / 2.0f;
	float maxRadius = std::sqrt(centerX * centerX + centerY * centerY);
	float strength = 0.009f; // Adjust this value for more or less swirl

	for (int y = 0; y < image.rows; ++y) {
		for (int x = 0; x < image.cols; ++x) {
			float offsetX = x - centerX;
			float offsetY = y - centerY;
			float radius = std::sqrt(offsetX * offsetX + offsetY * offsetY);
			float angle = std::atan2(offsetY, offsetX) + strength * (maxRadius - radius);
			int newX = static_cast<int>(centerX + radius * std::cos(angle));
			int newY = static_cast<int>(centerY + radius * std::sin(angle));

			if (newX >= 0 && newX < image.cols && newY >= 0 && newY < image.rows) {
				swirled_image.at<cv::Vec3b>(y, x) = image.at<cv::Vec3b>(newY, newX);
			}
		}
	}

	// Display the original and swirled images
	cv::imshow("Original Image", image);
	cv::imshow("Swirled Image", swirled_image);

	// Wait for 0 to be pressed and then close the windows
	cv::waitKey(0);
	cv::destroyAllWindows();
}


void wave() 
{
	// Load the image using file path
	std::string imagePath = "Images/Lena_24bits.bmp";
	cv::Mat image = cv::imread(imagePath);
	if (image.empty()) {
		std::cerr << "Could not open or find the image!" << std::endl;
		return;
	}

	// Create an output image
	cv::Mat waved_image = image.clone();

	// Parameters for the wave effect
	float frequency = 0.1f; // Adjust for the frequency of the wave
	float amplitude = 10.0f; // Adjust for the amplitude of the wave

	for (int y = 0; y < image.rows; ++y) {
		for (int x = 0; x < image.cols; ++x) {
			int newX = static_cast<int>(x + amplitude * std::sin(frequency * y));
			int newY = y;

			if (newX >= 0 && newX < image.cols) {
				waved_image.at<cv::Vec3b>(y, x) = image.at<cv::Vec3b>(newY, newX);
			}
		}
	}

	// Display the original and waved images
	cv::imshow("Original Image", image);
	cv::imshow("Waved Image", waved_image);

	// Wait for 0 to be pressed and then close the windows
	cv::waitKey(0);
	cv::destroyAllWindows();
}



			


int main()
{
	cv::utils::logging::setLogLevel(cv::utils::logging::LOG_LEVEL_FATAL);
	projectPath = _wgetcwd(0, 0);

	int op;
	do
	{
		system("cls");
		destroyAllWindows();
		printf("Menu:\n");
		printf(" 1 - Open image\n");
		printf(" 2 - Open BMP images from folder\n");
		printf(" 3 - Image negative\n");
		printf(" 4 - Image negative (fast)\n");
		printf(" 5 - BGR->Gray\n");
		printf(" 6 - BGR->Gray (fast, save result to disk) \n");
		printf(" 7 - BGR->HSV\n");
		printf(" 8 - Resize image\n");
		printf(" 9 - Canny edge detection\n");
		printf(" 10 - Edges in a video sequence\n");
		printf(" 11 - Snap frame from live video\n");
		printf(" 12 - Change Gray Level\n");
		printf(" 13 - Quarters Coloured\n");
		printf(" 14 - inv mat float\n");
		printf(" 15 - 4quadrants\n");
		printf(" 16 - ColortoGrayscale\n");
		printf(" 17 - GraytoBinary\n");
		printf(" 18 - DisplayHSV\n");
		printf(" 19 - isInside?\n");
		printf(" 20 - Histogram\n");
		printf(" 21 - Pdf\n");
		printf(" 22 - displayHistogram\n");
		printf(" 23 - Histogram Lower\n");
		printf(" 24 - ThreshHold\n");
		printf(" 25 - Floyd-Steinberg\n");
		printf(" 26 - mousecallback\n");
		printf(" 27 - labeled-colored\n");
		printf(" 28 - processOfLabeling\n");
		printf(" 29 - borderImage\n");
		printf(" 30 - chaincodederivative\n");
		printf(" 31 - Reconstruct\n");
		printf(" 32 - Dilation\n");
		printf(" 33 - Erosion\n");
		printf(" 34 - Opening\n");
		printf(" 35 - Closing\n");
		printf(" 36 - Dilation_n\n");
		printf(" 37 - Erosion_n\n");
		printf(" 38 - Opening_n\n");
		printf(" 39 - Closing_n\n");
		printf(" 40 - Histogram\n");
		printf(" 41 - Binarization\n");
		printf(" 42 - Equalized Histogram\n");
		printf(" 43 - Arithmetic filter\n");
		printf(" 44 - Gaussian filter\n");
		printf(" 45 - LaPlace filter\n");
		printf(" 46 - Highpass filter \n");
		printf(" 47 - Median Filter\n");
		printf(" 48 - Gaussian 2 filter\n");
		printf(" 49 - GaussianLowPass\n");
		printf(" 50 - GaussianHighPass\n");
		printf(" 51 - Magnitude\n");
		printf(" 52 - gradient\n");
		printf(" Image Warping-PROJECT\n");
		printf(" 53 - warping\n");
		printf(" 54 - morphing\n");
		printf(" 55 - swirl\n");
		printf(" 56 - wave\n");
		printf(" 0 - Exit\n\n");
		printf("Option: ");
		scanf("%d", &op);
		switch (op)
		{
		case 1:
			testOpenImage();
			break;
		case 2:
			testOpenImagesFld();
			break;
		case 3:
			testNegativeImage();
			break;
		case 4:
			testNegativeImageFast();
			break;
		case 5:
			testColor2Gray();
			break;
		case 6:
			testImageOpenAndSave();
			break;
		case 7:
			testBGR2HSV();
			break;
		case 8:
			testResize();
			break;
		case 9:
			testCanny();
			break;
		case 10:
			testVideoSequence();
			break;
		case 11:
			testSnap();
			break;
		case 12:
			changeGrayLevel();
			break;
		case 13:
			quartersColoured();
			break;
		case 14:
			floatMat();
			break;
		case 15:
			test4Quadrants();
			break;
		case 16:
			testColortoGrayscale();
			break;
		case 17:
			testGraytoBinary();
			break;
		case 18:
			computeAndDisplayHSVMatrix();
			break;
		case 19:
			checkIfInsideImage();
			break;
		case 20:
			histogram();
			break;
		case 21:
			PDF();
			break;
		case 22:
			printHistogram();
			break;
		case 23:
			histogramLower();
			break;
		case 24:
			threshHold();
			break;
		case 25:
			FloydSteinberg();
			break;
		case 26:
			MouseClick();
			break;
		case 27:
			labeling();
			break;
		case 28:
			processOfLabeling();
			break;
		case 29:
			borderTracing();
			break;
		case 30:
			chainCodeDer();
			break;
		case 31:
			reconstruct();
			break;
		case 32:
			dilation();
			break;
		case 33:
			erosion();
			break;
		case 34:
			opening();
			break;
		case 35:
			closing();
			break;
		case 36:
			dilation_n();
			break;
		case 37:
			erosion_n();
			break;
		case 38:
			opening_n();
			break;
		case 39:
			closing_n();
			break;
		case 40:
			infoHistogram();
			break;
		case 41:
			Binarization();
			break;
		case 42:
			EqualHistogram();
			break;
		case 43:
			arithmeticFilter();
			break;
		case 44:
			gaussianFilter();
			break;
		case 45:
			laPlaceFilter();
			break;
		case 46:
			highPassFilter();
			break;
		case 47:
			medianFilter();
			break;
		case 48:
			gaussianFilter2();
			break;
		case 49:
			idealLowPass();
			break;
		case 50:
			GaussianHighPass();
			break;
		case 51:
			Magnitude();
			break;
		case 52:
			gradient();
			break;
		case 53:
			warping();
			break;
		case 54:
			morphing();
			break;
		case 55:
			swirl();
			break;
		case 56:
			wave();
			break;
		}
	} while (op != 0);
	return 0;
}