Source.cpp

#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/opencv.hpp>

#include <iostream>
#include <string>
#include <Windows.h>
#include <algorithm>
#include <chrono>
#include <thread>


#define MIN_RADIUS 1.9
#define PI 3.14159

using namespace cv;

class Target
{
public:
	double Distance;
	Point Position;
	double Radius;
	int Index;
};

bool CompareTargets(const Target& target1, const Target& target2)
{
	if (target1.Distance < target2.Distance)
		return true;
	else if (target1.Distance > target2.Distance)
		return false;
	else {
		if (std::abs(target1.Index - target2.Index) <= 1) {
			return target1.Index < target2.Index;
		}
		else {
			return false;
		}
	}
}

void clickMouse()
{
	while (true)
	{

		if (GetAsyncKeyState('X') & 0x8000)
		{
			mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
			mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
		}

		std::this_thread::sleep_for(std::chrono::milliseconds(1));
	}
}

Mat CaptureWindow(HWND hWND) {
	HDC deviceContext = GetDC(hWND);
	HDC memoryDeviceContext = CreateCompatibleDC(deviceContext);
	RECT windowRect;
	GetClientRect(hWND, &windowRect);
	int height = windowRect.bottom;
	int width = windowRect.right;
	HBITMAP bitmap = CreateCompatibleBitmap(deviceContext, width, height);
	SelectObject(memoryDeviceContext, bitmap);
	BitBlt(memoryDeviceContext, 0, 0, width, height, deviceContext, 0, 0, SRCCOPY);
	BITMAPINFOHEADER bi;
	bi.biSize = sizeof(BITMAPINFOHEADER);
	bi.biWidth = width;
	bi.biHeight = -height;
	bi.biPlanes = 1;
	bi.biBitCount = 32;
	bi.biCompression = BI_RGB;
	bi.biSizeImage = 0;
	bi.biXPelsPerMeter = 1;
	bi.biYPelsPerMeter = 2;
	bi.biClrUsed = 3;
	bi.biClrImportant = 4;
	Mat mat = Mat(height, width, CV_8UC4);
	GetDIBits(memoryDeviceContext, bitmap, 0, height, mat.data, (BITMAPINFO*)&bi, DIB_RGB_COLORS);
	DeleteObject(bitmap);
	DeleteDC(memoryDeviceContext);
	ReleaseDC(hWND, deviceContext);
	return mat;
}



void printMatInfo(const cv::Mat& image)
{
	std::cout << "Rows: " << image.rows << std::endl;
	std::cout << "Columns: " << image.cols << std::endl;
	std::cout << "Channels: " << image.channels() << std::endl;
	std::cout << "Data Type: " << image.type() << std::endl;
	std::cout << "Pixel Format: " << image.depth() << std::endl;
	std::cout << "Element Size: " << image.elemSize() << " bytes" << std::endl;
	std::cout << "Total Size: " << image.total() * image.elemSize() << " bytes" << std::endl;
	std::cout << "Is Continuous: " << (image.isContinuous() ? "Yes" : "No") << std::endl;
}


void MoveCursorTowardsTarget(int targetX, int targetY, const cv::Mat& image, int moveAmount)
{
	int screenWidth = image.cols;
	int screenHeight = image.rows;

	int centerX = screenWidth / 2;
	int centerY = (screenHeight + 23) / 2;

	int deltaX = targetX - centerX;
	int deltaY = targetY - centerY;

	double distance = sqrt(deltaX * deltaX + deltaY * deltaY);

	double directionX = deltaX / distance;
	double directionY = deltaY / distance;

	int moveX = static_cast<int>(directionX * moveAmount);
	int moveY = static_cast<int>(directionY * moveAmount);

	mouse_event(MOUSEEVENTF_MOVE, moveX, moveY, 0, 0);
}

int main()
{
	setUseOptimized(true);
	

	std::string window_title = "aimlab_tb";
	HWND hWND = FindWindow(NULL, window_title.c_str());
	HANDLE cHandle = GetStdHandle(STD_OUTPUT_HANDLE);

	hWND = GetDesktopWindow();
	while (!hWND) {
		SetConsoleCursorPosition(cHandle, {0, 0});
		std::cout << "Waiting for " + window_title + "...      \n        ";
		hWND = FindWindow(NULL, window_title.c_str());
		Sleep(100);
	}
	namedWindow("Window", WINDOW_KEEPRATIO);
	std::thread t(clickMouse);
	std::vector<Target> targets;
    while (true)
    {
		auto start = std::chrono::high_resolution_clock::now();

		Mat image = CaptureWindow(hWND);
		Mat red_mask, mat;

		cv::cvtColor(image, image, cv::COLOR_RGB2BGR);
		cv::cvtColor(image, image, cv::COLOR_RGB2BGR);
		inRange(image, cv::Scalar(0, 0, 150), cv::Scalar(40, 40, 255), red_mask);

		rectangle(red_mask, cv::Rect(static_cast<int>(899), 0, static_cast<int>(104), static_cast<int>(90)), cv::Scalar(0), -1);
		std::vector<std::vector<cv::Point>> contours = {};
		findContours(red_mask, contours, mat, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);

		for (int i = 0; i < contours.size(); i++) 
		{
			double contour_area = contourArea(contours[i]);
			double contour_radius = sqrt(contour_area / PI);

			if (contour_radius < MIN_RADIUS) {
				continue;
			}

			drawContours(image, contours, i, Scalar(0, 255, 0), 2);
			std::vector<cv::Point> contour = contours[i];
			
			Moments mo = moments(contour);
			int cX = static_cast<int>(mo.m10 / mo.m00);
			int cY = static_cast<int>(mo.m01 / mo.m00);

			Point center = Point(image.cols / 2, (image.rows + 23)  / 2);
			Point circle_pos = Point(cX, cY);


			int distance = static_cast<int>(std::round(std::sqrt(std::pow(circle_pos.x - center.x, 2) + std::pow(circle_pos.y - center.y, 2))));

			Scalar line_color(255, 255, 255);
			Scalar circle_color(255, 255, 255);
			
			circle(image, circle_pos, contour_radius / 3 , circle_color, -1, LINE_AA);
			line(image, center, circle_pos, line_color, 1, LINE_AA);

			putText(image, "Radius: " + std::to_string(contour_radius).substr(0, 4), Point(cX - 20, cY - 10 - contour_radius), FONT_HERSHEY_DUPLEX, 0.5, Scalar(255, 255, 255), 1, LINE_AA);
			putText(image, "Distance: " + std::to_string(distance).substr(0, 5), Point(cX - 20, cY - 30 - contour_radius), FONT_HERSHEY_DUPLEX, 0.5, Scalar(255, 255, 255), 1, LINE_AA);
			putText(image, "Target: " + std::to_string(i + 1), Point(cX - 20, cY - 50 - contour_radius), FONT_HERSHEY_DUPLEX, 0.5, Scalar(255, 255, 255), 1, LINE_AA);

			Target target{distance, circle_pos, contour_radius, i};
			targets.push_back(target);
		}

		if (targets.size() > 0) {
			Target closest = *std::min_element(targets.begin(), targets.end(), CompareTargets);

			line(image, Point(image.cols / 2, (image.rows + 23) / 2) , closest.Position, Scalar(0, 255, 0), 1.1, LINE_AA);
			circle(image, closest.Position, closest.Radius / 3, Scalar(0, 255, 0), -1, LINE_AA);

			if (closest.Distance < 1) 
			{/*
				mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
				Sleep(1);
				mouse_event(MOUSEEVENTF_LEFTUP  , 0, 0, 0, 0);*/
			}
			else
			{
				MoveCursorTowardsTarget(closest.Position.x, closest.Position.y, image, (int)(3 * closest.Distance));
			}
		}



		auto end = std::chrono::high_resolution_clock::now();
		auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);

		putText(image, "FPS: " + std::to_string(1000 / duration.count()).substr(0, 5), Point(10, 20), FONT_HERSHEY_DUPLEX, 0.5, Scalar(255, 255, 255), 1, LINE_AA);


		cv::imshow("Window", image);
		targets.clear();
		if (waitKey(1) == 27) {
			destroyAllWindows();
			break;
		};

    }
    return 0;
}