WindowsProject.cpp

// WindowsProject.cpp : Defines the entry point for the application.
//

#include "framework.h"
#include "WindowsProject.h"
#include <opencv2/core.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <filesystem> // C++17 standard header file name
#include <opencv2/features2d.hpp>
#include <opencv2/calib3d.hpp>
#include <iostream>
#include <windows.h>  // For MessageBoxA (Win32)
#include <shlwapi.h>  // For Win32 file system functions, if needed

#include <opencv2/opencv.hpp>
#include <tesseract/baseapi.h>
#include <leptonica/allheaders.h>

namespace fs = std::filesystem;


//////////////////
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <Windows.h>

#include <windef.h>
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
#include "commdlg.h"
#include <Wingdi.h>
#include <gdiplus.h>
#include <set>

//////////////////////
using namespace cv;
using namespace std;
#define MAX_LOADSTRING 100

OPENFILENAME ofn; // êîíñòðóêòîð çà ÷åòåíå/ïèñàíå íà ôàéë ïî èìå
char FileName[128]; //èìà íà âõîäíî èçîáðàæåíèå
char FileNameOut[128];//èìå íà èçõîäåí ôàéë
char path[128];			//äèðåêòîðèÿ íà âõîäíîòî èçîáðàæåíèå
char pathOut[128];		//äèðåòêòîðèÿ íà èçõîäåí ôàéë
char Title[128];
wchar_t szFilter[] = _TEXT("All Files(*.*)\0*.*\0\0");

// Global Variables:
HINSTANCE hInst;                                // current instance
WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name


HBITMAP hbmHBITMAP1 = NULL;// ìàíèïóëàòîð êúì âõîäíîòî èçîáðàæåíèå
LPBITMAPINFOHEADER m_lpBMIH1 = NULL;//çàãëàâàí ÷àñò íà âõîäíîòî èçîáðàæåíèå 
BYTE* image1;// áàéòîâ ìàñèâ íà âõîäíîòî èçîáðàæåíèå 
//potrebitelski promenlivi - za h-fajl
char* imname; //óêàçàòåë êúì èìå íà âõîäåí ôàéë
float width, height; //ðàçìåðè íà äúùåðåí ïðîçîðåö
Mat image; /// Ãëîáàëåí Mat îáåêò çà èçîáðàæåíèå
//ïðîìåíëèâè çà GDIPlus
GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR gdiplusToken;

cv::Mat resizeImage(const cv::Mat& imageInput, int largestSizeDimension) {
	// Resize the image while keeping the aspect ratio
	cv::Mat resizedImage;
	int targetSize = largestSizeDimension;
	int width = imageInput.cols;
	int height = imageInput.rows;

	float aspectRatio = static_cast<float>(width) / height;
	cv::Size newSize;

	if (width > height) {
		newSize = cv::Size(targetSize, static_cast<int>(targetSize / aspectRatio));
	}
	else {
		newSize = cv::Size(static_cast<int>(targetSize * aspectRatio), targetSize);
	}

	cv::resize(imageInput, resizedImage, newSize);
	return resizedImage;
}

cv::Mat preprocessImage(const cv::Mat& imageInput) {
	// Check if the image is valid
	if (imageInput.empty()) {
		std::cerr << "Invalid image provided!" << std::endl;
		return cv::Mat();
	}

	// Resize the image to a standard size for consistent processing
	cv::Mat resizedImage = resizeImage(imageInput, 800);

	// Convert the image to HSV color space
	cv::Mat hsvImage;
	cv::cvtColor(resizedImage, hsvImage, cv::COLOR_BGR2HSV);

	// Mask the red color (lower and upper ranges)
	cv::Mat redMask1, redMask2, redMask;
	cv::inRange(hsvImage, cv::Scalar(0, 100, 100), cv::Scalar(10, 255, 255), redMask1); // Lower red
	cv::inRange(hsvImage, cv::Scalar(160, 100, 100), cv::Scalar(180, 255, 255), redMask2); // Upper red
	cv::bitwise_or(redMask1, redMask2, redMask); // Combine both masks

	// Clean up the red mask using morphological operations
	cv::Mat kernel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(2, 2));
	cv::morphologyEx(redMask, redMask, cv::MORPH_CLOSE, kernel); // Close small gaps
	cv::morphologyEx(redMask, redMask, cv::MORPH_OPEN, kernel);  // Remove noise

	// Optional (Visualization for debugging)
	cv::imshow("Red Mask", redMask);
	cv::waitKey(1000); // Display for 1 second

	return redMask;
}

std::vector<cv::Rect> detectStopSignContours(const cv::Mat& redMask, cv::Mat& debugImage) {
	// Detect contours in the red mask
	std::vector<std::vector<cv::Point>> contours;
	cv::findContours(redMask, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

	// Visualize all contours for debugging
	cv::drawContours(debugImage, contours, -1, cv::Scalar(255, 0, 0), 2); // Draw contours in blue

	// Filter contours by area and shape
	std::vector<cv::Rect> candidateRegions;
	for (const auto& contour : contours) {
		double area = cv::contourArea(contour);
		if (area < 1000) continue; // Ignore small contours

		// Approximate the contour to a polygon
		std::vector<cv::Point> approxContour;
		cv::approxPolyDP(contour, approxContour, 0.02 * cv::arcLength(contour, true), true);

		// Check if the contour has 6 to 10 sides
		if (approxContour.size() >= 6 && approxContour.size() <= 10) {
			// Store the bounding rectangle of the potential stop sign
			candidateRegions.push_back(cv::boundingRect(approxContour));
		}
	}

	return candidateRegions;
}

std::string performOCR(const cv::Mat& image) {
	// Initialize tesseract OCR engine
	tesseract::TessBaseAPI tess;
	if (tess.Init("..\\..\\", "eng")) { // Initialize tesseract with English language
		std::cerr << "Could not initialize tesseract!" << std::endl;
		return "";
	}

	// Convert OpenCV image to grayscale for OCR
	cv::Mat grayImage;
	cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);

	// Set the image for OCR
	tess.SetImage(grayImage.data, grayImage.cols, grayImage.rows, 1, grayImage.cols);

	// Perform OCR
	std::string ocrResult = tess.GetUTF8Text();
	return ocrResult;
}

void processStopSignImage(HWND hwnd, const cv::Mat& imageInput) {
	cv::Mat resizedImage = resizeImage(imageInput, 800);
	

	// Preprocess the image to extract red mask
	cv::Mat redMask = preprocessImage(imageInput);

	if (redMask.empty()) {
		std::cerr << "Error processing image!" << std::endl;
		return;
	}

	// Resize the input image to match the red mask size
	cv::Mat debugImage = resizedImage.clone();

	// Detect potential stop sign regions
	std::vector<cv::Rect> detectedRegions = detectStopSignContours(redMask, debugImage);

	// For each detected region, crop and perform OCR
	for (const auto& rect : detectedRegions) {
		// Crop the region of interest (ROI) from the resized image
		cv::Mat roi = resizedImage(rect);
		cv:Mat roiResized = resizeImage(roi, 200);

		// In case of a strong perspective distortion it would be a good idea to perform homography (perspective transformation

		// Perform OCR to detect text inside the stop sign region
		std::string ocrText = performOCR(roiResized);

		// Check if the OCR result contains the word "STOP" (case-insensitive)
		std::string lowerOcrText = toLowerCase(ocrText);  // Convert OCR result to lowercase
		if (lowerOcrText.find("stop") != std::string::npos) {  // Compare to lowercase "stop"
			// Draw a green rectangle around the detected stop sign
			cv::rectangle(resizedImage, rect, cv::Scalar(0, 255, 0), 2);
			// Optionally, print OCR text for debugging
			std::cout << "Detected STOP sign with OCR text: " << ocrText << std::endl;
		}
	}

	// Display the results
	imshow("Contours Detection", debugImage);
	imshow("Stop Signs Detection", resizedImage);
	cv::waitKey(0);
}


void recognizeNoEntrySign(HWND hWnd, const Mat& inputImage) {
	// Resize the image
	cv::Mat resizedImage = resizeImage(inputImage, 800);
	
	// Convert to HSV color space
	Mat hsvImage;
	cvtColor(resizedImage, hsvImage, COLOR_BGR2HSV);


	// Create a red mask
	Mat mask1, mask2, redMask;
	Scalar lowerRed1(0, 70, 50), upperRed1(10, 255, 255);
	Scalar lowerRed2(170, 70, 50), upperRed2(180, 255, 255);

	inRange(hsvImage, lowerRed1, upperRed1, mask1);
	inRange(hsvImage, lowerRed2, upperRed2, mask2);
	bitwise_or(mask1, mask2, redMask);

	// Morphological operations to clean the mask
	Mat kernel = getStructuringElement(MORPH_ELLIPSE, cv::Size(5, 5));
	morphologyEx(redMask, redMask, MORPH_CLOSE, kernel);

	// Show the red mask
	imshow("Red Mask", redMask);
	waitKey(0);

	// Find contours in the red mask
	vector<vector<cv::Point>> contours;
	findContours(redMask, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

	// Debug: Draw contours on a separate image
	Mat debugImage = resizedImage.clone();
	cv::drawContours(debugImage, contours, -1, cv::Scalar(255, 0, 0), 2); // Draw contours in blue

	// Proceed with detection logic
	Mat outputImage = resizedImage.clone();

	for (const auto& contour : contours) {
		// Filter circular shapes
		double area = contourArea(contour);
		double perimeter = arcLength(contour, true);
		if (perimeter == 0) continue;


		std::vector<cv::Point> approx;
		cv::approxPolyDP(contour, approx, 0.01 * perimeter, true);

		// Additional check to improve accuracy
		if (approx.size() == 8) {
			continue;
		}

		double circularity = 4 * CV_PI * area / (perimeter * perimeter);
		if (circularity > 0.7 && area > 500) { // Circularity threshold
			// Get bounding box of the detected circle
			cv::Rect boundingBox = boundingRect(contour);
			Mat roi = resizedImage(boundingBox);

			// Threshold for white regions inside the ROI
			Mat roiHSV;
			cvtColor(roi, roiHSV, COLOR_BGR2HSV);
			Mat whiteMask;
			inRange(roiHSV, Scalar(0, 0, 200), Scalar(180, 50, 255), whiteMask);

			// Find contours in the white mask
			vector<vector<cv::Point>> whiteContours;
			findContours(whiteMask, whiteContours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

			for (const auto& whiteContour : whiteContours) {
				RotatedRect rect = minAreaRect(whiteContour);
				Size2f size = rect.size;

				if (size.width > size.height) {
					// Draw a green rectangle around the no-entry sign
					rectangle(outputImage, boundingBox, Scalar(0, 255, 0), 3);
				}
			}
		}
	}

	// Display results
	imshow("Contours Detection", debugImage);
	imshow("No Entry Signs Detection", outputImage);
	waitKey(0);
}

long Datasize(LPBITMAPINFOHEADER m_lpBMIH)
{//ïîìîùíà ôóíêöèÿ çà îïðåäåëÿíå íà ðàçìåðà íà ìàñèâà íà èçîáðàæåíèåòî
	long sizeImage;
	int p, dump;
	p = 0;
	if (m_lpBMIH->biBitCount == 8) p = 1;
	if (m_lpBMIH->biBitCount == 24) p = 3;
	dump = (m_lpBMIH->biWidth * p) % 4;
	if (dump != 0) dump = 4 - dump;
	sizeImage = m_lpBMIH->biHeight * (m_lpBMIH->biWidth + dump);
	return sizeImage;
}

int Mask(int iSliderValue)
{ //ïîìîùíà ôóíêöèÿ çà îïðåäåëÿíå íà ðàçìåð íà ìàñêà ñëåä èçáîð ïî ðóëåð
	int MaskSize;
	if (iSliderValue < 4)  MaskSize = 3; else
		if (iSliderValue < 6) MaskSize = 5; else
			if (iSliderValue < 8) MaskSize = 7; else
				if (iSliderValue < 10) MaskSize = 9; else MaskSize = 11;
	return MaskSize;
}

char* Uni2char(char* FileNameOut)
{ //ôóíêöèÿ çà òðàíñôîðìàöèÿ êúì Óíèêîä
	char* imname0;
	size_t origsize = wcslen((LPWSTR)FileNameOut) + 1;
	size_t convertedChars = 0;
	char strConcat[] = " (char *)";
	size_t strConcatsize = (strlen(strConcat) + 1) * 2;
	const size_t newsize = origsize * 2;
	imname0 = new char[newsize + strConcatsize];
	int errrr = wcstombs_s(&convertedChars, imname0, newsize, (LPWSTR)FileNameOut, _TRUNCATE);
	if (errrr == 0) return imname0; else return 0;
}
void saveimage(HWND hWnd, Mat imResult)
{// ïîìîùíà ïðîöåäóðà çà çàïèñ íà ôàéë ñ ÷åòåíå íà èìå è ïðåîáðàçóâàíå â óíèêîä
	char* imnameOut;
	wchar_t defex[] = __TEXT("*.*");
	*FileNameOut = 0;
	RtlZeroMemory(&ofn, sizeof ofn);
	ofn.lStructSize = sizeof ofn;
	ofn.hwndOwner = hWnd;
	ofn.hInstance = hInst;
	ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
	ofn.lpstrFilter = (LPWSTR)szFilter;
	ofn.lpstrDefExt = (LPWSTR)defex;
	ofn.lpstrCustomFilter = (LPWSTR)szFilter;


	ofn.lpstrFile = (LPWSTR)FileNameOut;
	ofn.nMaxFile = sizeof FileNameOut;

	ofn.lpstrInitialDir = (LPCWSTR)pathOut;
	if (GetSaveFileName(&ofn) != 0)
	{
		size_t origsize = wcslen((LPWSTR)FileNameOut) + 1;
		size_t convertedChars = 0;
		char strConcat[] = " (char*)";
		size_t strConcatsize = (strlen(strConcat) + 1) * 2;
		const size_t newsize = origsize * 2;
		imnameOut = new char[newsize + strConcatsize];
		int errrr = wcstombs_s(&convertedChars, imnameOut, newsize, (LPWSTR)FileNameOut, _TRUNCATE);
		if (errrr == 0)	imwrite(imnameOut, imResult);
		delete[] imnameOut;
	}


}

//

HBITMAP LoadFileImage(wchar_t* FileName); //ôóíêöèÿ çà çàðåæäàíå íà âúíøíî èçîáðàæåíèå
void getDataHBITMAP(HBITMAP hbmHBITMAP); //ïðîöåäóðà çà èçâëè÷àíå íà äàííèòå çà èçîáðàæåíèåòî
BOOL DisplayBmpJPG(HWND hWnd, HBITMAP hbmHBITMAP); //ôóíêöèÿ çà âèçóàëèçàöèÿ íà èçîáðàæåíèåòî â îñíîâíèÿ åêðàí


// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
	_In_opt_ HINSTANCE hPrevInstance,
	_In_ LPWSTR    lpCmdLine,
	_In_ int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

	// TODO: Place code here.

	// Initialize global strings
	LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadStringW(hInstance, IDC_WINDOWSPROJECT, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Perform application initialization:
	if (!InitInstance(hInstance, nCmdShow))
	{
		return FALSE;
	}

	HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_WINDOWSPROJECT));

	MSG msg;

	// Main message loop:
	while (GetMessage(&msg, nullptr, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return (int)msg.wParam;
}



//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEXW wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style = CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc = WndProc;
	wcex.cbClsExtra = 0;
	wcex.cbWndExtra = 0;
	wcex.hInstance = hInstance;
	wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_WINDOWSPROJECT));
	wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
	wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
	wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_WINDOWSPROJECT);
	wcex.lpszClassName = szWindowClass;
	wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassExW(&wcex);
}

//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
	hInst = hInstance; // Store instance handle in our global variable

	HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);

	if (!hWnd)
	{
		return FALSE;
	}

	ShowWindow(hWnd, nCmdShow);
	UpdateWindow(hWnd);

	return TRUE;
}

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE: Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_COMMAND:
	{
		int wmId = LOWORD(wParam);
		// Parse the menu selections:
		switch (wmId)
		{
		case   ID_RECOGNIZE_STOP_SIGN:
		{
			processStopSignImage(hWnd, image);
			break;
		}
		case   ID_RECOGNIZE_NO_ENTRY_SIGN:
		{
			recognizeNoEntrySign(hWnd, image);
			break;
		}
		case IDM_ABOUT:
			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
			break;
			///////////////////////////////////
		case ID_FILE_INPUTIMAGE32798:
		{//çàðåæäàíå íà èçîáðàæåíèå ñëåä èçáîð íà èìå
			wchar_t defex[] = __TEXT("*.*");
			*FileName = 0;
			RtlZeroMemory(&ofn, sizeof ofn);
			ofn.lStructSize = sizeof ofn;
			ofn.hwndOwner = hWnd;
			ofn.hInstance = hInst;
			ofn.lpstrFile = (LPWSTR)FileName;
			ofn.nMaxFile = sizeof FileName;
			ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
			ofn.lpstrFilter = (LPWSTR)szFilter;
			ofn.lpstrDefExt = (LPWSTR)defex;
			ofn.lpstrCustomFilter = (LPWSTR)szFilter;
			ofn.lpstrInitialDir = (LPCWSTR)path;

			if (GetOpenFileName(&ofn) != 0)
			{
				size_t origsize = wcslen((LPWSTR)FileName) + 1;
				size_t convertedChars = 0;
				char strConcat[] = " (char *)";
				size_t strConcatsize = (strlen(strConcat) + 1) * 2;
				const size_t newsize = origsize * 2;
				imname = new char[newsize + strConcatsize];
				wcstombs_s(&convertedChars, imname, newsize, (LPWSTR)FileName, _TRUNCATE);


				GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
				hbmHBITMAP1 = LoadFileImage((LPWSTR)FileName);
				getDataHBITMAP(hbmHBITMAP1);
				GdiplusShutdown(gdiplusToken);
				image = imread(imname, 1);
				delete[] imname;
			}
			else {}

		}

		break;
		case ID_IMPROC_AVERAGE32776:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{

				Mat imResult;  //ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà

				namedWindow("Averaged", 0); //ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Averaged", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				//Create trackbar to change masksize
				int iSliderValue1 = 1;
				createTrackbar("kernelSize", "Averaged", &iSliderValue1, 11);
				while (true)
				{
					int MaskSize = Mask(iSliderValue1); //îïðåäåëÿíå íà ðàçìåðà íà ìàñêàòà

					blur(image, imResult, Size2i(MaskSize, MaskSize));//ôèëòðàöèÿ
					imshow("Averaged", imResult);//âèçóàëèçàöèÿ íà ðåóëòàò

					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);
						if (iKey == 27) break;

					}
				}
			}
			break;
		case ID_IMPROC_MEDIAN:
			if (image.dims == 2)// ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult; // ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà

				namedWindow("Median", 0); // ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Median", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				//Create trackbar to change kernelsize
				int iSliderValue1 = 1;
				createTrackbar("kernelSize", "Median", &iSliderValue1, 11);
				while (true)
				{
					int MaskSize = Mask(iSliderValue1);//îïðåäåëÿíå íà ðàçìåðà íà ìàñêàòà
					medianBlur(image, imResult, MaskSize); //ôèëòðàöèÿ
					imshow("Median", imResult);//âèçóàëèçàöèÿ íà ðåóëòàò

					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}

			}
			break;

		case ID_IMPROC_GAUSS:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult;// ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà
									//		
				namedWindow("GaussBlur", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("GaussBlur", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				//Create trackbar to change brightness
				int iSliderValue1 = 1;

				createTrackbar("kernelSize", "GaussBlur", &iSliderValue1, 11);
				while (true)
				{
					int MaskSize = Mask(iSliderValue1);//îïðåäåëÿíå íà ðàçìåðà íà ìàñêàòà
					GaussianBlur(image, imResult, Size2i(MaskSize, MaskSize), 0, 0);//ôèëòðàöèÿ
					imshow("GaussBlur", imResult);//âèçóàëèçàöèÿ íà ðåóëòàò

					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}
			break;

		case ID_IMPROC_SOBEL:
			if (image.dims == 2)// ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult;// ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà

				namedWindow("Sobel", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Sobel", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				int b = 1;
				createTrackbar("scale", "Sobel", &b, 100);

				while (true)
				{
					Sobel(image, imResult, image.depth(), 1, 1, 3, b, 0, BORDER_DEFAULT);//äèôåðåíöèðàíå

					imshow("Sobel", imResult);//âèçóàëèçàöèÿ íà ðåóëòàò

					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}

			break;

		case ID_IMPROC_LAPLAS:
			if (image.dims == 2)// ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult;// ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà

				namedWindow("Laplacian", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Laplacian", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				int b = 1;
				createTrackbar("scale", "Laplacian", &b, 100);



				while (true)
				{
					Laplacian(image, imResult, image.depth(), 1, b, 0, BORDER_DEFAULT);//äèôåðåíöèðàíå

					imshow("Laplacian", imResult);//âèçóàëèçàöèÿ íà ðåóëòàò
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}
			break;
		case ID_HISTOGRAMS_CALC:
			if (image.dims == 2)// ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				int histSize = 256; //çàäàâàíå íà ðàçìåð íà ìàñèâà íà õèñòîãðàìàòà
				Mat imResult;  // áóôåðíî èçîáðàæåíèå
				MatND Bh;   //ìàñèâ çà ñàìàòà õèñòîãðàìà
				image.copyTo(imResult);
				namedWindow("Histogram", 0);   // ãåíåðèðàíå íà ïðîçîðåö
				int channels[] = { 0, 1, 2, 3 }; // äåôèíèðàíå íà êàíàëèòå çà 32-áèòîâî èçîáðàæåíèå
				calcHist(&imResult, 1, channels, Mat(), Bh, 1, &histSize, 0); //ïðåñìÿòàíå íà õèñòîãðàìà çà ïúðâè êàíàë
				Mat histImage = Mat::ones(200, 320, CV_8U) * 255; //îãðàíè÷àâàíå íà ìàòðèöà çà âèçóàëèçàöèÿ íà õèñòîãðàìàòà
				normalize(Bh, Bh, 0, histImage.rows, NORM_MINMAX, CV_32F);//íîðìàëèçàöèÿ íà äàííèòå â õèñòîãðàìàòà
				histImage = Scalar::all(255);  //ïðåîáðàçóâàíâ â ñêàëàðíà ñòîéíîñò
				int binW = cvRound((double)histImage.cols / histSize);//îïðåäåëÿíå íà ïîçèöèÿ çà âèçóàëèçàöèÿ
				for (int i = 0; i < histSize; i++)
					rectangle(histImage, Point2i(i * binW, histImage.rows),
						Point2i((i + 1) * binW, histImage.rows - cvRound(Bh.at<float>(i))),
						Scalar::all(0), -1, 8, 0);
				imshow("Histogram", histImage);//âèçóàëèçàöèÿ íà õèñòîãðàìàòà
				while (true)
				{
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, histImage);//çàïèñ íà õèñòîãðàìàòà
						if (iKey == 27) break;

					}
				}

			}
			break;
		case ID_HISTOGRAMS_EQUILIZE:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult, img_hist_equalized;  // ðàáîòíè ìàñèâè
				cvtColor(image, imResult, COLOR_BGR2GRAY); //ïðåîáðàçóâàíå â ñèâî èçîáðàæåíèå
				equalizeHist(imResult, img_hist_equalized);//åêâèëèçàöèÿ íà õèñòîãðàìàòà
				namedWindow("Equilized image", 0);//ñúçäàâàíå íà ïðîçîðåö
				resizeWindow("Equilized image", int(width), int(height));//îãðàíè÷àâàíå íà ïðîçîðåöà
				imshow("Equilized image", img_hist_equalized);//âèçóàëèçàöèÿ íà ðåçóëòàòà
				while (true)
				{
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, img_hist_equalized);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}

			break;


		case ID_HISTOGRAMS_COMPARE:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult; //ðàáîòåí ìàñèâ
				image.copyTo(imResult);
				//èçáîå íà èìå íà âòîðîòî èçîáðàæåíèå			
				char* imnameOut;
				*FileNameOut = 0;
				ofn.lpstrFile = (LPWSTR)FileNameOut;
				ofn.nMaxFile = sizeof FileNameOut;

				ofn.lpstrInitialDir = (LPCWSTR)pathOut;
				if (GetOpenFileName(&ofn) == 0)
				{
					break;
				}
				else {

					imnameOut = Uni2char(FileNameOut);  //ïðåîáðàçóâàíå íà èìàòåî â óíèêîä
					Mat secondIm;    // ìàñèâ çà âòîðîòî èçîáðàæåíèå
					secondIm = imread(imnameOut, 1);// çàðåæäàíå íà âòîðîòî èçèáðàæåíèå
					namedWindow("Second Image", 0);  //åêðàí çà âèçóàëèçàöèÿ íà âòîðîòî èçîáðàæåíèå
					resizeWindow("Second Image", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà åêðàíà 
																		//ïî ðàçìåðèòå íà ïúðâîòî èçîáðàæååíèå

					imshow("Second Image", secondIm);//âèçóàëèçàöèÿ íà âòîðîòî èçîáðàæåíèå
					delete imnameOut;

					int histSize = 256;  //îãðàíè÷àâàíå íà ðàçìåðà íà ìàñèâèòå íà õèñòîãðàìèòå

					float ranges[] = { 0, 256 };

					MatND hist1, hist2;//çàäàâàíå íà ìàñèâè çà õèñòîãðàìèòå

					int channels[] = { 0, 1, 2, 3 };//äåôèíèðàíå íà êàíàëèòå
					//ïðåñìÿòàíå íà õèñòîãðàìèòå ïî ïúðâèÿ êàíàë

					calcHist(&imResult, 1, channels, Mat(), hist1, 1, &histSize, 0);

					calcHist(&secondIm, 1, channels, Mat(), hist2, 1, &histSize, 0);

					// èçáîð íà èìå íà ôàéë çà ñúõðàíÿâàíå íà èíôîðìàöèÿòà
					errno_t err;
					FILE* fstr;
					*FileNameOut = 0;
					ofn.lpstrFile = (LPWSTR)FileNameOut;
					ofn.nMaxFile = sizeof FileNameOut;
					ofn.lpstrInitialDir = (LPCWSTR)pathOut;
					if (GetSaveFileName(&ofn) != 0)
					{
						char* imname = Uni2char(FileNameOut);

						err = fopen_s(&fstr, imname, "w+");
						if (err == 0)
						{//ïðåñìÿòàíå íà êîåôèöèåíòèòå è çàïèñ íà ðåçóëòàòèòå
							double self = compareHist(hist1, hist1, HISTCMP_CORREL);// CV_COMP_CORREL);
							double comp = compareHist(hist1, hist2, HISTCMP_CORREL);// CV_COMP_CORREL);
							fprintf_s(fstr, " Method Compare corell: self = %f comp= %f \n", self, comp);
							self = compareHist(hist1, hist1, HISTCMP_CHISQR);// CV_COMP_CHISQR);
							comp = compareHist(hist1, hist2, HISTCMP_CHISQR);// CV_COMP_CHISQR);
							fprintf_s(fstr, " Method Compare chsqr: self = %f comp= %f \n", self, comp);
							self = compareHist(hist1, hist1, HISTCMP_INTERSECT);// CV_COMP_INTERSECT);
							comp = compareHist(hist1, hist2, HISTCMP_INTERSECT);// CV_COMP_INTERSECT);
							fprintf_s(fstr, " Method Compare intersect: self = %f comp= %f \n", self, comp);
							self = compareHist(hist1, hist1, HISTCMP_BHATTACHARYYA);// CV_COMP_BHATTACHARYYA);
							comp = compareHist(hist1, hist2, HISTCMP_BHATTACHARYYA);// CV_COMP_BHATTACHARYYA);
							fprintf_s(fstr, " Method Compare bhattacharyya: self = %f comp= %f \n", self, comp);
							fclose(fstr);
							delete imname;
						}
					}
				}
			}
			break;


		case ID_MORPHOLOGY_ERODE:
			if (image.dims == 2)// ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult; // ðàáîòåí ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà
				image.copyTo(imResult);

				namedWindow("Erode", 0); // ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Erode", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				//çàäàâàíå íà ñòðóêòóðåí åëåìåíò 
				Mat element = getStructuringElement(MORPH_RECT, Size2i(3, 3), Point2i(1, 1));

				erode(image, imResult, element);//åðîçèÿ
				imshow("Erode", imResult);//âèçóàëèçàöèÿ íà ðåçóëòàòà
				while (true)
				{
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}

			break;
		case ID_MORPHOLOGY_DILATE:
			if (image.dims == 2)// ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult;// ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà
				image.copyTo(imResult);

				namedWindow("Dilate", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Dilate", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				//çàäàâàíå íà ñòðóêòóðåí åëåìåíò 
				Mat element = getStructuringElement(MORPH_RECT, Size2i(3, 3), Point2i(1, 1));

				dilate(image, imResult, element);//äèëàòàöèÿ
				imshow("Dilate", imResult);//âèçóàëèçàöèÿ íà ðåçóëòàòà
				while (true)
				{
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}

			break;

		case ID_MORPHOLOGY_OPEN:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult;// ðàáîòåí ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà
				image.copyTo(imResult);

				namedWindow("Open", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Open", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				//çàäàâàíå íà ñòðóêòóðåí åëåìåíò
				Mat element = getStructuringElement(MORPH_RECT, Size2i(3, 3), Point2i(1, 1));

				morphologyEx(image, imResult, MORPH_OPEN, element);// îïåðàöèÿ "îòâàðÿíå"

				imshow("Open", imResult);
				while (true)
				{
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);// âèçóàëèçàöèÿ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}
			break;

		case ID_MORPHOLOGY_CLOSE:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult;// ðàáîòåí ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà
				image.copyTo(imResult);

				namedWindow("Close", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Close", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				//çàäàâàíå íà ñòðóêòóðåí åëåìåíò
				Mat element = getStructuringElement(MORPH_RECT, Size2i(3, 3), Point2i(1, 1));

				morphologyEx(image, imResult, MORPH_CLOSE, element);// îïðåàöèÿ ïî çàòâàðÿíå
				imshow("Close", imResult);// âèçóàëèçàöèÿ íà ðåçóëòàòà
				while (true)
				{
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);// âèçóàëèçàöèÿ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}
			break;

		case ID_TRANSPORMS_MAKEBINARY:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imGrayScale, imResult;// ðàáîòíè ìàñèâè 
				image.copyTo(imResult);
				cvtColor(imResult, imGrayScale, COLOR_RGB2GRAY);//ïðåîáðàçóâàíå â ñèâî èçîáðàæåíèå
				namedWindow("Binary", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Binary", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà


				//thresholding the grayscale image to get better results
				int treshold = 127;
				createTrackbar("treshold", "Binary", &treshold, 254);// ãåíåðèðàíå íà ðóëåð çà ïðàã
				while (true)
				{
					threshold(imGrayScale, imResult, treshold, 255, THRESH_BINARY);// áèíàðèçàöèÿ
					imshow("Binary", imResult);// âèçóàëèçàöèÿ íà ðåçóëòàòà


					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);// çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}
			break;

		case ID_TRANSPORMS_MAKEGRAY:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat gray_image; // ðàáîòåí ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà
				cvtColor(image, gray_image, COLOR_RGB2GRAY);//ïðåîáðàçóâàíå â ñèâî èçîáðàæåíèå

				namedWindow("Gray image", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Gray image", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				imshow("Gray image", gray_image);//âèçóàëèçàöèÿ íà ðåçóëòàòà
				while (true)
				{
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, gray_image);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}
			}

			break;

		case ID_TRANSPORMS_FOURIER:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat gray_image; // ðàáîòåí ìàñèâ çà ðåçóëòàòà îò îáðàáîòêàòà

				cvtColor(image, gray_image, COLOR_RGB2GRAY);//ïðåîáðàçóâàíå â ñèâî èçîáðàæåíèå
				namedWindow("Gray image", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Gray image", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				imshow("Gray image", gray_image);//âèçóàëèçàöèÿ íà ðåçóëòàòà
				int M = getOptimalDFTSize(gray_image.rows);
				int N = getOptimalDFTSize(gray_image.cols);
				Mat padded; //ñúçäàâàíå íà ìàñèâ ñ ïîäõîäÿù ðàçìåð çà DFT
				copyMakeBorder(gray_image, padded, 0, M - gray_image.rows, 0, N - gray_image.cols, BORDER_CONSTANT, Scalar::all(0));

				Mat planes[] = { Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F) };
				Mat complexImg;//çàäàâàíå íà êîìïëåêñåí ìàñèâ
				merge(planes, 2, complexImg);//ïðåîáðàçóâà íÿêîëêî åäíîêàíàëíè ìàñèâà â åäèí êîìïëåêñåí

				dft(complexImg, complexImg);//Ôóðèå òðàíñôîðìàöèÿ

				// compute log(1 + sqrt(Re(DFT(img))**2 + Im(DFT(img))**2))
				split(complexImg, planes); //ðàçäåëÿ êîìïëåñíèÿ ìàñèâ íÿêîëêî åäíîêàíàëíè ìàñèâà
				magnitude(planes[0], planes[1], planes[0]); //ïðåñìÿòàíå íà êâàäðàò íà àìïëèòóäàòà (çà âèçóàëèçàöèÿ)
				Mat mag = planes[0];
				mag += Scalar::all(1);
				log(mag, mag);

				// crop the spectrum, if it has an odd number of rows or columns
				mag = mag(Rect2i(0, 0, mag.cols & -2, mag.rows & -2));

				int cx = mag.cols / 2;
				int cy = mag.rows / 2;

				// rearrange the quadrants of Fourier image
				// so that the origin is at the image center
				//öåíòðèðàíå íà ñïåêòúðà â ïîëåòî çà âèçóàëèçàöèÿ
				Mat tmp;
				Mat q0(mag, Rect2i(0, 0, cx, cy));
				Mat q1(mag, Rect2i(cx, 0, cx, cy));
				Mat q2(mag, Rect2i(0, cy, cx, cy));
				Mat q3(mag, Rect2i(cx, cy, cx, cy));

				q0.copyTo(tmp);
				q3.copyTo(q0);
				tmp.copyTo(q3);

				q1.copyTo(tmp);
				q2.copyTo(q1);
				tmp.copyTo(q2);

				normalize(mag, mag, 0, 1, NORM_MINMAX);//íîðìàëèçàöèÿ íà äàííèòå
				namedWindow("spectrum magnitude", 0);// ãåíåðèðàíå íà ïðîçîðåö
				imshow("spectrum magnitude", mag);//âèçóàëèçàöèÿ íà ðåçóëòàòà

			}
			break;

		case ID_DETECTION_CANNYEDGE:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat dst, cdst;// ðàáîòíè ìàñèâè
				namedWindow("Canny edge detected", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("Canny edge detected", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				int treshold_low = 1;
				createTrackbar("tr_low", "Canny edge detected", &treshold_low, 521);//ãåíåðèðàíå íà ðóëåð çà äîëåí ïðàã
				int treshold_up = 255;
				createTrackbar("tr_up", "Canny edge detected", &treshold_up, 522);//ãåíåðèðàíå íà ðóëåð çà ãîðåí ïðàã
				while (true)
				{

					Canny(image, dst, treshold_low, treshold_up, 3);//îêîíòóðÿâàíå
					imshow("Canny edge detected", dst);//âèçóàëèçàöèÿ íà ðåçóëòàòà

					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, dst);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}

			}
			break;

		case ID_DETECTION_HOUGHLINES:
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat dst, cdst;// ðàáîòíè ìàñèâè
				namedWindow("edge detected lines", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("edge detected lines", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				int treshold_low = 1;
				createTrackbar("tr_low", "edge detected lines", &treshold_low, 254);//ãåíåðèðàíå íà ðóëåð çà äîëåí ïðàã
				int treshold_up = 255;
				createTrackbar("tr_up", "edge detected lines", &treshold_up, 255);//ãåíåðèðàíå íà ðóëåð çà ãîðåí ïðàã
				while (true)
				{

					Canny(image, dst, treshold_low, treshold_up, 3);// îêîíòóðÿâàíå
					imshow("edge detected lines", dst);
					int iKey = waitKey(50);
					if (iKey == 27)
					{
						break;
					}
				}


				cvtColor(dst, cdst, COLOR_GRAY2BGR);//ïðåîáðàçóâàíå â ñèâî èçîáðàæåíèå

				namedWindow("detected lines", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("detected lines", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà

				vector<Vec4i> lines;
				int treshold = 1;
				createTrackbar("treshold", "detected lines", &treshold, 254);//ãåíåðèðàíå íà ðóëåð çà ïðàã
				int LL = 255;
				createTrackbar("Line", "detected lines", &LL, 255);//ãåíåðèðàíå íà ðóëåð çà äúëæèíà

				while (true)
				{
					HoughLinesP(dst, lines, 1, CV_PI / 180, treshold, LL, 5);//Õàô òðàíñôîðìàöèÿ
					for (size_t i = 0; i < lines.size(); i++)
					{//íàìèðàíå íà òúðñåíèòå åëåìåíòè
						Vec4i l = lines[i];
						line(cdst, Point2i(l[0], l[1]), Point2i(l[2], l[3]), Scalar(0, 0, 255), 3, LINE_AA);
					}

					imshow("detected lines", cdst);//âèèçóàëèçàöèÿ íà ðåçóëòàòà

					int	iKey = waitKey(50);

					if (iKey == 119) //w
						saveimage(hWnd, cdst);//çàïèñ íà ðåçóëòàòà
					if (iKey == 27) break;


				}

			}
			break;

		case ID_DETECTION_HOUGH32797:
			//îòêðèâàíå íà îêðúæíîñòè
			if (image.dims == 2) // ïðîâåðêà çà ïðåõâúðëåí ìàñèâ â Mat ìàñèâ
			{
				Mat imResult, dst;// ðàáîòíè ìàñèâè
				//		
				cvtColor(image, imResult, COLOR_RGB2GRAY);//ïðåîáðàçóâàíå â ñèâî èçîáðàæåíèå
				medianBlur(imResult, imResult, 5);//ôèëòðàöèÿ ÷ðåç óñðåäíÿâàíå 5õ5

				Mat cimg;//ðàáîòåí ìàñèâ

				cvtColor(imResult, cimg, COLOR_GRAY2BGR);//ïðåîáðàçóâàíå â ñèâî èçîáðàæåíèå
				namedWindow("detected circles", 0);// ãåíåðèðàíå íà ïðîçîðåö
				resizeWindow("detected circles", int(width), int(height));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà
				vector<Vec3f> circles; //âåêòîð íà òúðñåíèòå îêðúæíîñòè

				int min_r = 1120;
				createTrackbar("min_r", "detected circles", &min_r, 1120);//ãåíåðèðàíå íà ðóëåð çà ìèíèìàëåí ðàäèóñ
				int max_r = 1150;
				createTrackbar("max_r", "detected circles", &max_r, 1150);//ãåíåðèðàíå íà ðóëåð çà ìàêñèìàëåí ðàäèóñ

				while (true)
				{
					//âèçóàëèçàöèÿ íà ðåçóëòàòà
					if (min_r <= max_r)
					{
						HoughCircles(imResult, circles, HOUGH_GRADIENT, 1, 10, 100, 30, min_r, max_r); //õàô òðàíñôîðìàöèÿ

						for (size_t i = 0; i < circles.size(); i++)
						{//îòêðèâàíå íà òúðñåíèòå åëåìåíòè
							Vec3i c = circles[i];
							circle(cimg, Point2i(c[0], c[1]), c[2], Scalar(0, 0, 255), 2, LINE_AA);
							circle(cimg, Point2i(c[0], c[1]), 2, Scalar(0, 255, 0), 2, LINE_AA);
						}

						imshow("detected circles", cimg);//âèçóàëèçàöèÿ íà ðåçóëòàòà
					}
					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w
							saveimage(hWnd, imResult);//çàïèñ íà ðåçóëòàòà
						if (iKey == 27) break;

					}
				}

			}
			break;

		case ID_VIDEO:
		{
			VideoCapture cap(0);//êîíñòðóêòîð çà âèäåî
			namedWindow("Video", 1);// ãåíåðèðàíå íà ïðîçîðåö

			if (!cap.isOpened())  // if not success, exit program
			{
				break;
			}
			else
			{
				double dWidth = cap.get(CAP_PROP_FRAME_WIDTH); //get the width of frames of the video
				double dHeight = cap.get(CAP_PROP_FRAME_HEIGHT); //get the height of frames of the video

				Size2i frameSize(static_cast<int>(dWidth), static_cast<int>(dHeight));//îãðàíè÷àâàíå íà ðàçìåðà íà ïðîçîðåöà

				int b = 100;
				int c = 50;

				namedWindow("corrected", 1);
				for (;;)
				{
					createTrackbar("brightness = + - b", "corrected", &b, 200);
					int br = b - 100;
					createTrackbar("cfontrast =*c", "corrected", &c, 100);
					double contr = double(c) / 50;
					Mat frame;// ðàáîòåí ìàñèâ çà êàäðèòå
					cap >> frame;
					if (frame.empty())
						break;
					Mat imResult; //ìàñèâ çà êîðèãèðàíî èçîáðàæåíèå
					frame.convertTo(imResult, -1, contr, br);
					imshow("corrected", imResult);
					imshow("Video", frame);

					int	iKey = waitKey(50);
					if ((iKey == 27) || (iKey == 119))
					{
						if (iKey == 119) //w 
						{// çàäàâàíå íà èìå íà èçõîäåí êàäúð
							wchar_t defex[] = __TEXT("*.*");
							*FileNameOut = 0;
							RtlZeroMemory(&ofn, sizeof ofn);
							ofn.lStructSize = sizeof ofn;
							ofn.hwndOwner = hWnd;
							ofn.hInstance = hInst;
							ofn.lpstrFile = (LPWSTR)FileNameOut;
							ofn.nMaxFile = sizeof FileNameOut;
							ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
							ofn.lpstrFilter = (LPWSTR)szFilter;
							ofn.lpstrDefExt = (LPWSTR)defex;
							ofn.lpstrCustomFilter = (LPWSTR)szFilter;
							ofn.lpstrInitialDir = (LPCWSTR)path;
							if (GetSaveFileName(&ofn) != 0)
							{
								char* imnameOut;
								imnameOut = Uni2char(FileNameOut);
								if (imnameOut != 0) imwrite(imnameOut, imResult);// çàïèñ íà êàäúð
								delete imnameOut;
							}
						}
						if (iKey == 27) break;//èçõîä  ïðè íàòèñíàò „esc“

					}
				}


			}

		}
		break;


		case IDM_EXIT:
			DestroyWindow(hWnd);
			break;
		default:
			return DefWindowProc(hWnd, message, wParam, lParam);
		}
	}
	break;
	case WM_PAINT:
	{
		/*       PAINTSTRUCT ps;
			   HDC hdc = BeginPaint(hWnd, &ps);
			   // TODO: Add any drawing code that uses hdc here...

			  Mat image = Mat::zeros(300, 600, CV_8UC3);
			   circle(image, Point(250, 150), 100, Scalar(0, 255, 128), -100);
			   circle(image, Point(350, 150), 100, Scalar(255, 255, 255), -100);
			   imshow("Display Window", image);
			   EndPaint(hWnd, &ps);*/
		{	GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
		if (hbmHBITMAP1 != 0)	DisplayBmpJPG(hWnd, hbmHBITMAP1);
		GdiplusShutdown(gdiplusToken);
		}
	}
	break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	UNREFERENCED_PARAMETER(lParam);
	switch (message)
	{
	case WM_INITDIALOG:
		return (INT_PTR)TRUE;

	case WM_COMMAND:
		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hDlg, LOWORD(wParam));
			return (INT_PTR)TRUE;
		}
		break;
	}
	return (INT_PTR)FALSE;
}


HBITMAP LoadFileImage(wchar_t* FileName)
{
	// âúâúåæäà èçîáðàæåíèå îò ôàéë ñ ïîìîùòà íà GDI+

	Bitmap* pbmp = Bitmap::FromFile(FileName);
	HBITMAP JPGImage;
	if (pbmp == NULL) JPGImage = NULL;
	else
		if (Ok != pbmp->GetHBITMAP(Color::Black, &JPGImage))
			JPGImage = NULL;

	delete pbmp;
	return JPGImage;
}

void getDataHBITMAP(HBITMAP hbmHBITMAP)
{
	//èçâëè÷àíå íà îïèñàíèåòî è ìàòðèöàòà íà èçîáðàæåíèåòî 
	LPBYTE m_lpImage;
	DIBSECTION ds;

	::GetObject(hbmHBITMAP, sizeof(ds), &ds);
	if (m_lpBMIH1 != NULL) delete[] m_lpBMIH1;
	m_lpBMIH1 = (LPBITMAPINFOHEADER) new char[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
	memcpy(m_lpBMIH1, &ds.dsBmih, sizeof(BITMAPINFOHEADER));
	if (m_lpBMIH1->biSizeImage == 0)
		m_lpBMIH1->biSizeImage = Datasize(m_lpBMIH1);

	// êîïèðàíå íà ìàòðèöàòà íà èçîáðàæåíèåòî
	m_lpImage = (LPBYTE)ds.dsBm.bmBits;
	// ìàñèâ ñ èçîáðàæåíèåòî
	image1 = m_lpImage; //íà âñåêè èíäåêñ îò ìàñèâà èìà êîìïîíåíòà B, G, R èëè „ïðîçðà÷íîñò“
}

BOOL DisplayBmpJPG(HWND hWnd, HBITMAP hbmHBITMAP)
{  //âèçóàëèçàöèÿ ñ GDI íà HBITMAP 

	RECT rcDest;
	rcDest.top = 0;
	rcDest.left = 0;
	rcDest.right = m_lpBMIH1->biWidth;
	rcDest.bottom = m_lpBMIH1->biHeight;

	Graphics g(::GetDC(hWnd));

	RECT rc;
	::GetClientRect(hWnd, &rc);

	float scalex = float(rc.right) / float(rcDest.right);
	float scaley = float(rc.bottom) / float(rcDest.bottom);

	width = float(rcDest.right);
	height = float(rcDest.bottom);

	if ((scalex >= 1) && (scaley >= 1)) {
		if (scalex > scaley) { width *= scaley; height *= scaley; }
		if (scalex <= scaley) { width *= scalex; height *= scalex; }
	}
	if ((scalex <= 1) && (scaley > 1)) { width = width * scalex; height = height * scalex; }
	if ((scalex > 1) && (scaley <= 1)) { width = width * scaley; height = height * scaley; }
	if ((scalex < 1) && (scaley < 1)) {
		if (scalex > scaley) { width *= scaley; height *= scaley; }
		if (scalex <= scaley) { width *= scalex; height *= scalex; }
	}
	Bitmap* pb = Bitmap::FromHBITMAP(hbmHBITMAP, NULL);


	//èç÷åðòàâàíå íà èçîáðàæåíèåòî â ãðàíèöèòå íà ïðîçîðåöà
	g.DrawImage(pb, float(rc.left), float(rc.top), width, height);

	delete pb;
	return true;
}