[ADD] added comments to startup_scene.h

you can switch between mouse and hand detection now

src/computervision/FaceDetector.cpp

@@ -0,0 +1,53 @@
+#include "FaceDetector.h"
+
+
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+namespace computervision
+{
+	Rect getFaceRect(Mat input);
+
+	String faceClassifierFileName = "res/haarcascade_frontalface_alt.xml";
+	CascadeClassifier faceCascadeClassifier;
+
+	FaceDetector::FaceDetector(void) {
+		if (!faceCascadeClassifier.load(faceClassifierFileName))
+			throw runtime_error("can't load file " + faceClassifierFileName);
+	}
+
+	void FaceDetector::removeFaces(Mat input, Mat output) {
+		vector<Rect> faces;
+		Mat frameGray;
+
+		cvtColor(input, frameGray, CV_BGR2GRAY);
+		equalizeHist(frameGray, frameGray);
+
+		faceCascadeClassifier.detectMultiScale(frameGray, faces, 1.1, 2, 0 | 2, Size(120, 120)); // HAAR_SCALE_IMAGE is 2
+
+		for (size_t i = 0; i < faces.size(); i++) {
+			rectangle(
+				output,
+				Point(faces[i].x, faces[i].y),
+				Point(faces[i].x + faces[i].width, faces[i].y + faces[i].height),
+				Scalar(0, 0, 0),
+				-1
+			);
+		}
+	}
+
+	Rect getFaceRect(Mat input) {
+		vector<Rect> faceRectangles;
+		Mat inputGray;
+
+		cvtColor(input, inputGray, CV_BGR2GRAY);
+		equalizeHist(inputGray, inputGray);
+
+		faceCascadeClassifier.detectMultiScale(inputGray, faceRectangles, 1.1, 2, 0 | 2, Size(120, 120)); // HAAR_SCALE_IMAGE is 2
+
+		if (faceRectangles.size() > 0)
+			return faceRectangles[0];
+		else
+			return Rect(0, 0, 1, 1);
+	}
+}

src/computervision/FaceDetector.h

@@ -0,0 +1,31 @@
+#pragma once
+#include <opencv2/opencv.hpp>
+#include <opencv2/imgproc/types_c.h>
+#include <opencv2/objdetect.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/objdetect/objdetect.hpp>
+/*
+ Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
+*/
+
+using namespace cv;
+using namespace std;
+
+namespace computervision
+{
+	class FaceDetector {
+	public:
+		/**
+		 * @brief Constructor for the class FaceDetector, loads training data from a file
+		 * 
+		 */
+		FaceDetector(void);
+		/**
+		 * @brief Detects faces on an image and blocks them with a black rectangle
+		 * 
+		 * @param input Input image
+		 * @param output Output image
+		 */
+		void removeFaces(Mat input, Mat output);
+	};
+}

src/computervision/FingerCount.cpp

@@ -14,7 +14,6 @@
 
 namespace computervision
 {
-
 	FingerCount::FingerCount(void) {
 		color_blue = Scalar(255, 0, 0);
 		color_green = Scalar(0, 255, 0);
@@ -36,6 +35,9 @@ namespace computervision
 		if (input_image.channels() != 1)
 			return contours_image;
 
+		vector<vector<Point>> contours;
+		vector<Vec4i> hierarchy;
+
 		findContours(input_image, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
 
 		// we need at least one contour to work
@@ -43,7 +45,7 @@ namespace computervision
 			return contours_image;
 
 		// find the biggest contour (let's suppose it's our hand)
-		biggest_contour_index = -1;
+		int biggest_contour_index = -1;
 		double biggest_area = 0.0;
 
 		for (int i = 0; i < contours.size(); i++) {
@@ -154,11 +156,6 @@ namespace computervision
 		return contours_image;
 	}
 
-	void FingerCount::DrawHandContours(Mat& image)
-	{
-		drawContours(image, contours, biggest_contour_index, color_green, 2, 8, hierarchy);
-	}
-
 	int FingerCount::getAmountOfFingers()
 	{
 		return amount_of_fingers;

src/computervision/FingerCount.h

@@ -31,15 +31,7 @@ namespace computervision
 		 */
 		int getAmountOfFingers();
 
-		void DrawHandContours(Mat& image);
-
 	private:
-
-		int biggest_contour_index;
-		vector<vector<Point>> contours;
-		vector<Vec4i> hierarchy;
-
-
 		// colors to use
 		Scalar color_blue;
 		Scalar color_green;
@@ -123,7 +115,5 @@ namespace computervision
 		 * @param with_numbers if the numbers should be drawn with the points
 		 */
 		void drawVectorPoints(Mat image, vector<Point> points, Scalar color, bool with_numbers);
-
-
 	};
 }

src/computervision/HandDetectRegion.cpp

@@ -1,105 +0,0 @@
-
-#include "HandDetectRegion.h"
-
-namespace computervision
-{
-
-	HandDetectRegion::HandDetectRegion(std::string id,int x_pos, int y_pos, int width, int height)
-	{
-		region_id = id;
-		start_x_pos = x_pos;
-		start_y_pos = y_pos;
-		region_width = width;
-		region_height = height;
-		hand_mask_generated = false;
-		hand_present = false;
-	}
-
-	void HandDetectRegion::DetectHand(cv::Mat& camera_frame)
-	{
-		Mat input_frame = GenerateHandMaskSquare(camera_frame);
-		frame_out = input_frame.clone();
-
-		// detect skin color
-		skin_detector.drawSkinColorSampler(camera_frame,start_x_pos,start_y_pos,region_width,region_height);
-
-		// remove background from image
-		foreground = background_remover.getForeground(input_frame);
-
-		// detect the hand contours
-		handMask = skin_detector.getSkinMask(foreground);
-
-		// draw the hand rectangle on the camera input, and draw text showing if the hand is open or closed.
-		DrawHandMask(&camera_frame);
-
-		//imshow("output" + region_id, frame_out);
-		//imshow("foreground" + region_id, foreground);
-		//imshow("handMask" + region_id, handMask);
-		/*imshow("handDetection", fingerCountDebug);*/
-
-		hand_present = hand_calibrator.CheckIfHandPresent(handMask,handcalibration::HandDetectionType::GAME);
-		//std::string text = (hand_present ? "hand" : "no");
-		//cv::putText(camera_frame, text, cv::Point(start_x_pos, start_y_pos), cv::FONT_HERSHEY_COMPLEX, 2.0, cv::Scalar(0, 255, 255), 2);
-		hand_calibrator.SetHandPresent(hand_present);
-
-		//draw black rectangle behind calibration information text
-		cv::rectangle(camera_frame, cv::Rect(0, camera_frame.rows - 55, 450, camera_frame.cols), cv::Scalar(0, 0, 0), -1);
-
-		hand_calibrator.DrawBackgroundSkinCalibrated(camera_frame);
-
-
-
-	}
-
-	cv::Mat HandDetectRegion::GenerateHandMaskSquare(cv::Mat img)
-	{
-		cv::Mat mask = cv::Mat::zeros(img.size(), img.type());
-		cv::Mat distance_img = cv::Mat::zeros(img.size(), img.type());
-
-		cv::rectangle(mask, cv::Rect(start_x_pos, start_y_pos, region_width, region_height), cv::Scalar(255, 255, 255), -1);
-
-		img.copyTo(distance_img, mask);
-
-		hand_mask_generated = true;
-		return distance_img;
-	}
-
-	bool HandDetectRegion::DrawHandMask(cv::Mat* input)
-	{
-		if (!hand_mask_generated) return false;
-		rectangle(*input, Rect(start_x_pos, start_y_pos, region_width, region_height), (hand_present ? Scalar(0, 255, 0) : Scalar(0,0,255)),2);
-		return true;
-	}
-
-	bool HandDetectRegion::IsHandPresent()
-	{
-		return hand_present;
-	}
-
-	void HandDetectRegion::CalibrateBackground()
-	{
-		std::cout << "calibrating background " << region_id << std::endl;
-		background_remover.calibrate(frame_out);
-		hand_calibrator.SetBackGroundCalibrated(true);
-	}
-	void HandDetectRegion::CalibrateSkin()
-	{
-		skin_detector.calibrate(frame_out);
-		hand_calibrator.SetSkinCalibration(true);
-	}
-
-	std::vector<int> HandDetectRegion::CalculateSkinTresholds()
-	{
-		std::cout << "calibrating skin " << region_id << std::endl;
-		hand_calibrator.SetSkinCalibration(true);
-		return skin_detector.calibrateAndReturn(frame_out);
-	}
-
-	void HandDetectRegion::setSkinTresholds(std::vector<int>& tresholds)
-	{
-		std::cout << "setting skin " << region_id << std::endl;
-		skin_detector.setTresholds(tresholds);
-		hand_calibrator.SetSkinCalibration(true);
-	}
-
-}

src/computervision/HandDetectRegion.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#include <opencv2/core.hpp>
-#include <opencv2/imgproc.hpp>
-#include "async/StaticCameraInstance.h"
-#include "calibration/HandCalibrator.h"
-#include "BackgroundRemover.h"
-#include "SkinDetector.h"
-#include "FingerCount.h"
-namespace computervision
-{
-	class HandDetectRegion
-	{
-	public:
-		HandDetectRegion(std::string id,int x_pos, int y_pos, int width, int height);
-
-		void SetXPos(int x) { start_x_pos = x; }
-		void SetYPos(int y) { start_y_pos = y; }
-		int GetXPos() { return start_x_pos; }
-		int GetYPos() { return start_y_pos; }
-
-		void SetWidth(int width) { region_width = width; }
-		void SetHeigth(int height) { region_height = height; }
-		int GetWidth() { return region_width; }
-		int GetHeight() { return region_height; }
-
-		cv::Mat GenerateHandMaskSquare(cv::Mat img);
-
-		void DetectHand(cv::Mat& camera_frame);
-
-		bool IsHandPresent();
-
-		void CalibrateBackground();
-		void CalibrateSkin();
-
-		std::vector<int> CalculateSkinTresholds();
-
-		void setSkinTresholds(std::vector<int>& tresholds);
-
-	private:
-		int start_x_pos;
-		int start_y_pos;
-		int region_height;
-		int region_width;
-		bool hand_mask_generated;
-		bool hand_present;
-		cv::Mat frame, frame_out, handMask, foreground, fingerCountDebug;
-		BackgroundRemover background_remover;
-		SkinDetector skin_detector;
-		handcalibration::HandCalibrator hand_calibrator;
-		std::string region_id;
-
-		bool DrawHandMask(cv::Mat* input);
-	};
-
-}

src/computervision/MenuTest.cpp

@@ -0,0 +1,25 @@
+#include "MenuTest.h"
+#include <iostream>
+
+namespace computervision 
+{
+	int menu_item_array[4] = { 1, 2, 3, 4 };
+	float item_number = 0;
+
+	MenuTest::MenuTest(void) {
+		
+	}
+
+	int MenuTest::GetMenuItem(bool hand_state) {
+		item_number += 0.20f;
+
+		
+		int temp_item_number = item_number;
+		//If temp_item_number is equal to the size of the array, set item_number bac to zero to loop through the array again
+		if (temp_item_number == sizeof(menu_item_array) / sizeof(menu_item_array[0])) {
+			item_number = 0;
+		}
+
+		return menu_item_array[temp_item_number];
+	}
+}

src/computervision/MenuTest.h

@@ -0,0 +1,18 @@
+
+namespace computervision
+{
+	class MenuTest {
+	public:
+		/**
+		 * @brief Constructor for the class MenuTest, loads in array with menu items
+		 *
+		 */
+		MenuTest(void);
+		/**
+		 * @brief Returns the itemnumber in an array 
+		 * 
+		 * @param input_bool is either true or false, depending on the recognized hand gesture
+		 */
+		int GetMenuItem(bool input_bool);
+	};
+}

src/computervision/ObjectDetection.cpp

@@ -6,142 +6,117 @@
 #include "ObjectDetection.h"
 #include "BackgroundRemover.h"
 #include "SkinDetector.h"
+#include "FaceDetector.h"
 #include "FingerCount.h"
-#include "async/StaticCameraInstance.h"
-#include "calibration/HandCalibrator.h"
 
 namespace computervision
 {
+	cv::VideoCapture cap(0);
 
-	cv::Mat img, img_gray, img2, img2_gray, img3, img4;
+	cv::Mat img, imgGray, img2, img2Gray, img3, img4;
 
-	int hand_mask_start_x_pos, hand_mask_start_y_pos, hand_mask_width, hand_mask_height;
+	int handMaskStartXPos, handMaskStartYPos, handMaskWidth, handMaskHeight;
-	bool hand_mask_generated = false;
+	bool handMaskGenerated = false;
 
-	Mat frame, frame_out, handMask, foreground, fingerCountDebug;
+	Mat frame, frameOut, handMask, foreground, fingerCountDebug;
-	BackgroundRemover background_remover;
+	BackgroundRemover backgroundRemover;
-	SkinDetector skin_detector;
+	SkinDetector skinDetector;
-	FingerCount finger_count;
+	FaceDetector faceDetector;
-	handcalibration::HandCalibrator hand_calibrator;
+	FingerCount fingerCount;
-
-	cv::VideoCapture cap = static_camera::getCap();
 
 	ObjectDetection::ObjectDetection()
 	{
 	}
 
-	cv::Mat ObjectDetection::ReadCamera() {
+	cv::Mat ObjectDetection::readCamera() {
 		cap.read(img);
 		return img;
 	}
 
-	cv::VideoCapture ObjectDetection::GetCap()
+	bool ObjectDetection::detectHand(Mat cameraFrame)
 	{
-		return cap;
+		Mat inputFrame = generateHandMaskSquare(cameraFrame);
-	}
+		frameOut = inputFrame.clone();
-
-	bool ObjectDetection::DetectHand(Mat camera_frame, bool& hand_present)
-	{
-		Mat input_frame = GenerateHandMaskSquare(camera_frame);
-		frame_out = input_frame.clone();
 
 		// detect skin color
-		skin_detector.drawSkinColorSampler(camera_frame);
+		skinDetector.drawSkinColorSampler(frameOut);
 
 		// remove background from image
-		foreground = background_remover.getForeground(input_frame);
+		foreground = backgroundRemover.getForeground(inputFrame);
 
 		// detect the hand contours
-		handMask = skin_detector.getSkinMask(foreground);
+		handMask = skinDetector.getSkinMask(foreground);
 
 		// count the amount of fingers and put the info on the matrix
-		fingerCountDebug = finger_count.findFingersCount(handMask, frame_out);
+		fingerCountDebug = fingerCount.findFingersCount(handMask, frameOut);
 
 		// get the amount of fingers
-		int fingers_amount = finger_count.getAmountOfFingers();
+		int fingers_amount = fingerCount.getAmountOfFingers();
 
 		// draw the hand rectangle on the camera input, and draw text showing if the hand is open or closed.
-		DrawHandMask(&camera_frame);
+		drawHandMaskRect(&cameraFrame);
-		
+		string hand_text = fingers_amount > 0 ? "open" : "closed";
-
+		putText(cameraFrame,hand_text, Point(10, 75), FONT_HERSHEY_PLAIN, 2.0, Scalar(255, 0, 255),3);
-		hand_calibrator.SetAmountOfFingers(fingers_amount);
+		imshow("camera", cameraFrame);
-		finger_count.DrawHandContours(camera_frame);
-		hand_calibrator.DrawHandCalibrationText(camera_frame);
-		imshow("camera", camera_frame);
-
-
-
-		/*imshow("output", frame_out);
-		imshow("foreground", foreground);
-		imshow("handMask", handMask);
-		imshow("handDetection", fingerCountDebug);*/
-
-		hand_present = hand_calibrator.CheckIfHandPresent(handMask,handcalibration::HandDetectionType::MENU);
-		hand_calibrator.SetHandPresent(hand_present);
-
 
+		//imshow("output", frameOut);
+		//imshow("foreground", foreground);
+		//imshow("handMask", handMask);
+		//imshow("handDetection", fingerCountDebug);
 
 		int key = waitKey(1);
 
 		if (key == 98) // b, calibrate the background
-		{
+			backgroundRemover.calibrate(inputFrame);
-			background_remover.calibrate(input_frame);
-			hand_calibrator.SetBackGroundCalibrated(true);
-		}
 		else if (key == 115) // s, calibrate the skin color
-		{
+			skinDetector.calibrate(inputFrame);
-			skin_detector.calibrate(input_frame);
-			hand_calibrator.SetSkinCalibration(true);
-
-		}
-
 
 		return fingers_amount > 0;
 	}
 
-	void ObjectDetection::CalculateDifference()
+	void ObjectDetection::calculateDifference()
 	{
 		cap.read(img);
 		cap.read(img2);
 
-		cv::cvtColor(img, img_gray, cv::COLOR_RGBA2GRAY);
+		cv::cvtColor(img, imgGray, cv::COLOR_RGBA2GRAY);
-		cv::cvtColor(img2, img2_gray, cv::COLOR_RGBA2GRAY);
+		cv::cvtColor(img2, img2Gray, cv::COLOR_RGBA2GRAY);
 
-		cv::absdiff(img_gray, img2_gray, img3);
+		cv::absdiff(imgGray, img2Gray, img3);
 		cv::threshold(img3, img4, 50, 170, cv::THRESH_BINARY);
 
 		imshow("threshold", img4);
 	}
 
 
-	cv::Mat ObjectDetection::GenerateHandMaskSquare(cv::Mat img)
+	cv::Mat ObjectDetection::generateHandMaskSquare(cv::Mat img)
 	{
-		hand_mask_start_x_pos = 20;
+		handMaskStartXPos = 20;
-		hand_mask_start_y_pos = img.rows / 5;
+		handMaskStartYPos = img.rows / 5;
-		hand_mask_width = img.cols / 3;
+		handMaskWidth = img.cols / 3;
-		hand_mask_height = img.cols / 3;
+		handMaskHeight = img.cols / 3;
 
 
 		cv::Mat mask = cv::Mat::zeros(img.size(), img.type());
-		cv::Mat distance_img = cv::Mat::zeros(img.size(), img.type());
+		cv::Mat dstImg = cv::Mat::zeros(img.size(), img.type());
 
-		cv::rectangle(mask, Rect(hand_mask_start_x_pos, hand_mask_start_y_pos, hand_mask_width, hand_mask_height), Scalar(255, 255, 255), -1);
+		cv::rectangle(mask, Rect(handMaskStartXPos, handMaskStartYPos, handMaskWidth, handMaskHeight), Scalar(255, 255, 255), -1);
 
-		img.copyTo(distance_img, mask);
+		img.copyTo(dstImg, mask);
 
-		hand_mask_generated = true;
+		handMaskGenerated = true;
-		return distance_img;
+		return dstImg;
 
 	}
 
-	bool ObjectDetection::DrawHandMask(cv::Mat* input)
+	bool ObjectDetection::drawHandMaskRect(cv::Mat* input)
 	{
-		if (!hand_mask_generated) return false;
+		if (!handMaskGenerated) return false;
-		rectangle(*input, Rect(hand_mask_start_x_pos, hand_mask_start_y_pos, hand_mask_width, hand_mask_height), Scalar(255, 255, 255));
+		rectangle(*input, Rect(handMaskStartXPos, handMaskStartYPos, handMaskWidth, handMaskHeight), Scalar(255, 255, 255));
 		return true;
 	}
 
-	void ObjectDetection::ShowWebcam()
+	void ObjectDetection::showWebcam()
 	{
 		imshow("Webcam image", img);
 	}

src/computervision/ObjectDetection.h

@@ -27,13 +27,13 @@ namespace computervision
 		 * @brief Displays an image of the current webcam-footage
 		 * 
 		 */
-		void ShowWebcam();
+		void showWebcam();
 		/**
 		 * @brief Calculates the difference between two images
 		 *  and outputs an image that only shows the difference
 		 * 
 		 */
-		void CalculateDifference();
+		void calculateDifference();
 
 		/**
 		 * @brief generates the square that will hold the mask in which the hand will be detected.
@@ -41,51 +41,29 @@ namespace computervision
 		 * @param img the current camear frame
 		 * @return a matrix containing the mask
 		 */
-		cv::Mat GenerateHandMaskSquare(cv::Mat img);
+		cv::Mat generateHandMaskSquare(cv::Mat img);
 
 		/**
 		 * @brief reads the camera and returns it in a matrix.
 		 * 
 		 * @return the camera frame in a matrix
 		 */
-		cv::Mat ReadCamera();
+		cv::Mat readCamera();
 
 		/**
 		 * @brief detects a hand based on the given hand mask input frame.
 		 * 
 		 * @param inputFrame the input frame from the camera
-		 * @param hand_present boolean that will hold true if the hand is detected, false if not.
 		 * @return true if hand is open, false if hand is closed
 		 */
-		bool DetectHand(cv::Mat camera_frame, bool& hand_present);
+		bool detectHand(cv::Mat cameraFrame);
 
 		/**
 		 * @brief draws the hand mask rectangle on the given input matrix.
 		 * 
 		 * @param input the input matrix to draw the rectangle on
 		 */
-		bool DrawHandMask(cv::Mat *input);
+		bool drawHandMaskRect(cv::Mat *input);
-
-		/**
-		 * @brief checks if the hand of the user is open.
-		 * 
-		 * @return true if the hand is open, false if not.
-		 */
-		bool IsHandOpen();
-
-
-		/**
-		 * @brief checks whether the hand is held within the detection square.
-		 * 
-		 * @return true if the hand is in the detection square, false if not.
-		 */
-		bool IsHandPresent();
-
-		cv::VideoCapture GetCap();
-
-	private:
-		bool is_hand_open;
-		bool is_hand_present;
 
 	};
 

src/computervision/OpenPoseVideo.cpp

@@ -1,108 +0,0 @@
-#include "OpenPoseVideo.h"
-
-using namespace std;
-using namespace cv;
-using namespace cv::dnn;
-
-namespace computervision
-{
-#define MPI
-
-#ifdef MPI
-	const int POSE_PAIRS[7][2] =
-	{
-		{0,1}, {1,2}, {2,3},
-		{3,4}, {1,5}, {5,6},
-		{6,7}
-	};
-
-	string protoFile = "res/pose/mpi/pose_deploy_linevec_faster_4_stages.prototxt";
-	string weightsFile = "res/pose/mpi/pose_iter_160000.caffemodel";
-
-	int nPoints = 8;
-#endif
-
-#ifdef COCO
-	const int POSE_PAIRS[17][2] =
-	{
-		{1,2}, {1,5}, {2,3},
-		{3,4}, {5,6}, {6,7},
-		{1,8}, {8,9}, {9,10},
-		{1,11}, {11,12}, {12,13},
-		{1,0}, {0,14},
-		{14,16}, {0,15}, {15,17}
-	};
-
-	string protoFile = "pose/coco/pose_deploy_linevec.prototxt";
-	string weightsFile = "pose/coco/pose_iter_440000.caffemodel";
-
-	int nPoints = 18;
-#endif
-	Net net;
-
-	void OpenPoseVideo::setup() {
-		net = readNetFromCaffe(protoFile, weightsFile);
-
-		net.setPreferableBackend(DNN_TARGET_CPU);
-	}
-
-	void OpenPoseVideo::movementSkeleton(Mat& inputImage, std::function<void(std::vector<Point>&, cv::Mat& poinst_on_image)> f) {
-		std::cout << "movement skeleton start" << std::endl;
-
-		int inWidth = 368;
-		int inHeight = 368;
-		float thresh = 0.01;
-
-		Mat frame;
-		int frameWidth = inputImage.size().width;
-		int frameHeight = inputImage.size().height;
-
-		double t = (double)cv::getTickCount();
-		std::cout << "reading input image and blob" << std::endl;
-
-		frame = inputImage;
-		Mat inpBlob = blobFromImage(frame, 1.0 / 255, Size(inWidth, inHeight), Scalar(0, 0, 0), false, false);
-
-		std::cout << "done reading image and blob" << std::endl;
-
-		net.setInput(inpBlob);
-
-		std::cout << "done setting input to net" << std::endl;
-		Mat output = net.forward();
-		std::cout << "time took to set input and forward: " << t << std::endl;
-
-		int H = output.size[2];
-		int W = output.size[3];
-
-		std::cout << "about to find position of boxy parts" << std::endl;
-		// find the position of the body parts
-		vector<Point> points(nPoints);
-		for (int n = 0; n < nPoints; n++)
-		{
-			// Probability map of corresponding body's part.
-			Mat probMap(H, W, CV_32F, output.ptr(0, n));
-
-			Point2f p(-1, -1);
-			Point maxLoc;
-			double prob;
-			minMaxLoc(probMap, 0, &prob, 0, &maxLoc);
-			if (prob > thresh)
-			{
-				p = maxLoc;
-				p.x *= (float)frameWidth / W;
-				p.y *= (float)frameHeight / H;
-
-				circle(frame, cv::Point((int)p.x, (int)p.y), 8, Scalar(0, 255, 255), -1);
-				cv::putText(frame, cv::format("%d", n), cv::Point((int)p.x, (int)p.y), cv::FONT_HERSHEY_COMPLEX, 1.1, cv::Scalar(0, 0, 255), 2);
-			}
-			points[n] = p;
-		}
-
-		cv::putText(frame, cv::format("time taken = %.2f sec", t), cv::Point(50, 50), cv::FONT_HERSHEY_COMPLEX, .8, cv::Scalar(255, 50, 0), 2);
-		std::cout << "time taken: " << t << std::endl;
-		//imshow("Output-Keypoints", frame);
-		//imshow("Output-Skeleton", frame);
-		std::cout << "about to call points receiving method" << std::endl;
-		f(points,frame);
-	}
-}

src/computervision/OpenPoseVideo.h

@@ -1,19 +0,0 @@
-#pragma once
-
-#include <opencv2/dnn.hpp>
-#include <opencv2/imgproc.hpp>
-#include <opencv2/highgui.hpp>
-#include <iostream>
-
-using namespace cv;
-
-namespace computervision
-{
-	class OpenPoseVideo{
-	private:
-
-	public:
-		void movementSkeleton(Mat& inputImage, std::function<void(std::vector<Point>&, cv::Mat& poinst_on_image)> f);
-		void setup();
-	};
-}

src/computervision/SkinDetector.cpp

@@ -1,5 +1,4 @@
 #include "SkinDetector.h"
-#include <iostream>
 
 /*
  Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti
@@ -24,7 +23,7 @@ namespace computervision
 		int frameWidth = input.size().width, frameHeight = input.size().height;
 
 		int rectangleSize = 25;
-		Scalar rectangleColor = Scalar(0, 255, 255);
+		Scalar rectangleColor = Scalar(255, 0, 255);
 
 		skinColorSamplerRectangle1 = Rect(frameWidth / 5, frameHeight / 2, rectangleSize, rectangleSize);
 		skinColorSamplerRectangle2 = Rect(frameWidth / 5, frameHeight / 3, rectangleSize, rectangleSize);
@@ -42,29 +41,6 @@ namespace computervision
 		);
 	}
 
-	void SkinDetector::drawSkinColorSampler(Mat input,int x, int y,int width, int height) {
-		int frameWidth = width, frameHeight = height;
-
-		int rectangleSize = 25;
-		Scalar rectangleColor = Scalar(0, 255, 255);
-
-		skinColorSamplerRectangle1 = Rect(frameWidth / 5 + x, frameHeight / 2 + y, rectangleSize, rectangleSize);
-		skinColorSamplerRectangle2 = Rect(frameWidth / 5 + x, frameHeight / 3 + y, rectangleSize, rectangleSize);
-
-		rectangle(
-			input,
-			skinColorSamplerRectangle1,
-			rectangleColor
-		);
-
-		rectangle(
-			input,
-			skinColorSamplerRectangle2,
-			rectangleColor
-		);
-	}
-
-
 	void SkinDetector::calibrate(Mat input) {
 
 		Mat hsvInput;
@@ -78,19 +54,6 @@ namespace computervision
 		calibrated = true;
 	}
 
-	std::vector<int> SkinDetector::calibrateAndReturn(Mat input)
-	{
-		Mat hsvInput;
-		cvtColor(input, hsvInput, CV_BGR2HSV);
-
-		Mat sample1 = Mat(hsvInput, skinColorSamplerRectangle1);
-		Mat sample2 = Mat(hsvInput, skinColorSamplerRectangle2);
-
-		calibrated = true;
-		return calculateAndReturnTresholds(sample1, sample2);
-
-	}
-
 	void SkinDetector::calculateThresholds(Mat sample1, Mat sample2) {
 		int offsetLowThreshold = 80;
 		int offsetHighThreshold = 30;
@@ -112,39 +75,6 @@ namespace computervision
 		//vHighThreshold = 255;
 	}
 
-	std::vector<int> SkinDetector::calculateAndReturnTresholds(Mat sample1, Mat sample2)
-	{
-		
-		calculateThresholds(sample1, sample2);
-		std::vector<int> res;
-		res.push_back(hLowThreshold);
-		res.push_back(hHighThreshold);
-		res.push_back(sLowThreshold);
-		res.push_back(sHighThreshold);
-		res.push_back(vLowThreshold);
-		res.push_back(vHighThreshold);
-		return res;
-	}
-
-	void SkinDetector::setTresholds(std::vector<int>& tresholds)
-	{
-		if (tresholds.size() != 6)
-		{
-			std::cout << "tresholds array not the right size!" << std::endl;
-			return;
-		}
-
-		hLowThreshold = tresholds[0];
-		hHighThreshold = tresholds[1];
-		sLowThreshold = tresholds[2];
-		sHighThreshold = tresholds[3];
-		vLowThreshold = tresholds[4];
-		vHighThreshold = tresholds[5];
-
-		calibrated = true;
-		
-	}
-
 	Mat SkinDetector::getSkinMask(Mat input) {
 		Mat skinMask;
 

src/computervision/SkinDetector.h

@@ -24,9 +24,6 @@ namespace computervision
 		*/
 		void drawSkinColorSampler(Mat input);
 
-		void drawSkinColorSampler(Mat input, int x, int y, int width, int heigth);
-
-
 		/*
 		* @brief calibrates the skin color detector with the given input frame
 		* 
@@ -34,10 +31,6 @@ namespace computervision
 		*/
 		void calibrate(Mat input);
 
-		std::vector<int> calibrateAndReturn(Mat input);
-
-		void setTresholds(std::vector<int>& tresholds);
-
 		/*
 		* @brief gets the mask for the hand
 		* 
@@ -70,8 +63,6 @@ namespace computervision
 		*/
 		void calculateThresholds(Mat sample1, Mat sample2);
 
-		std::vector<int> calculateAndReturnTresholds(Mat sample1, Mat sample2);
-
 		/**
 		 * @brief the opening. it generates the structuring element and performs the morphological transformations required to detect the hand.
 		 * This needs to be done to get the skin mask.

src/computervision/async/StaticCameraInstance.h

@@ -1,12 +0,0 @@
-#pragma once
-#include <opencv2/videoio.hpp>
-
-namespace static_camera
-{
-
-	static cv::VideoCapture getCap()
-	{
-		static cv::VideoCapture cap(0);
-		return cap;
-	}
-};

src/computervision/async/async_arm_detection.cpp

@@ -1,46 +0,0 @@
-#include <iostream>
-#include "async_arm_detection.h"
-#include "../OpenPoseVideo.h"
-#include <thread>
-#include "StaticCameraInstance.h"
-
-
-namespace computervision
-{
-	AsyncArmDetection::AsyncArmDetection()
-	{
-
-	}
-
-	void AsyncArmDetection::run_arm_detection(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op)
-	{
-		VideoCapture cap = static_camera::getCap();
-		
-		std::cout << "STARTING THREAD LAMBDA" << std::endl;
-		/*cv::VideoCapture cap = static_camera::GetCap();*/
-
-		if (!cap.isOpened())
-		{
-			std::cout << "capture was closed, opening..." << std::endl;
-			cap.open(0);
-		}
-
-		while (true)
-		{
-			Mat img;
-			cap.read(img);
-			op.movementSkeleton(img, points_ready_func);
-		}
-	}
-
-	void AsyncArmDetection::start(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op)
-	{
-
-		std::cout << "starting function" << std::endl;
-
-
-		std::thread async_arm_detect_thread(&AsyncArmDetection::run_arm_detection,this, points_ready_func, op);
-
-		async_arm_detect_thread.detach(); // makes sure the thread is detached from the variable.
-	}
-}

src/computervision/async/async_arm_detection.h

@@ -1,23 +0,0 @@
-#pragma once
-#include <vector>
-#include <opencv2/core/types.hpp>
-#include <opencv2/videoio.hpp>
-#include <functional>
-#include "../OpenPoseVideo.h"
-#include "StaticCameraInstance.h"
-
-
-namespace computervision
-{
-	class AsyncArmDetection
-	{
-	public:
-		AsyncArmDetection(void);
-
-		
-		void start(std::function<void(std::vector<cv::Point>, cv::Mat poinst_on_image)>, computervision::OpenPoseVideo op);
-	private:
-		void run_arm_detection(std::function<void(std::vector<Point>, cv::Mat poinst_on_image)> points_ready_func, OpenPoseVideo op);
-	};
-
-}

src/computervision/calibration/HandCalibrator.cpp

@@ -1,92 +0,0 @@
-
-#include "HandCalibrator.h"
-#include <iostream>
-
-#define MIN_MENU_HAND_SIZE 10000
-#define MIN_GAME_HAND_SIZE 3000 // todo change
-namespace computervision
-{
-	namespace handcalibration
-	{
-
-		HandCalibrator::HandCalibrator()
-		{
-
-		}
-
-		void HandCalibrator::DrawHandCalibrationText(cv::Mat& output_frame)
-		{
-			cv::rectangle(output_frame, cv::Rect(0, 0, output_frame.cols, 40), cv::Scalar(0, 0, 0), -1);
-			cv::putText(output_frame, "Hand calibration", cv::Point(output_frame.cols / 2 - 100, 25), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(18, 219, 65), 2);
-			cv::putText(output_frame, "press 'b' to calibrate background,then press 's' to calibrate skin tone", cv::Point(5, 35), cv::FONT_HERSHEY_PLAIN, 1.0, cv::Scalar(18, 219, 65), 1);
-
-			cv::rectangle(output_frame, cv::Rect(0, output_frame.rows - 80, 450, output_frame.cols), cv::Scalar(0, 0, 0), -1);
-
-			cv::putText(output_frame, "hand in frame:", cv::Point(5, output_frame.rows - 50), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(255, 255, 0), 1);
-			cv::rectangle(output_frame, cv::Rect(420, output_frame.rows - 67, 15, 15), hand_present ? cv::Scalar(0, 255, 0) : cv::Scalar(0, 0, 255), -1);
-
-			DrawBackgroundSkinCalibrated(output_frame);
-
-			if (hand_present)
-			{
-				std::string hand_text = fingers_amount > 0 ? "open" : "closed";
-				cv::putText(output_frame, hand_text, cv::Point(10, 75), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(255, 0, 255), 3);
-			}
-		}
-
-		void HandCalibrator::DrawBackgroundSkinCalibrated(cv::Mat& output_frame)
-		{
-
-			cv::putText(output_frame, "background calibrated:", cv::Point(5, output_frame.rows - 30), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(255, 255, 0), 1);
-			cv::rectangle(output_frame, cv::Rect(420, output_frame.rows - 47, 15, 15), background_calibrated ? cv::Scalar(0, 255, 0) : cv::Scalar(0, 0, 255), -1);
-
-			cv::putText(output_frame, "skin color calibrated:", cv::Point(5, output_frame.rows - 10), cv::FONT_HERSHEY_PLAIN, 2.0, cv::Scalar(255, 255, 0), 1);
-			cv::rectangle(output_frame, cv::Rect(420, output_frame.rows - 27, 15, 15), skintone_calibrated ? cv::Scalar(0, 255, 0) : cv::Scalar(0, 0, 255), -1);
-		}
-
-		void HandCalibrator::SetSkinCalibration(bool val)
-		{
-			skintone_calibrated = val;
-		}
-
-		void HandCalibrator::SetBackGroundCalibrated(bool val)
-		{
-			background_calibrated = val;
-		}
-
-		void HandCalibrator::SetHandPresent(bool val)
-		{
-			hand_present = val;
-		}
-
-		void HandCalibrator::SetAmountOfFingers(int amount)
-		{
-			fingers_amount = amount;
-		}
-
-		bool HandCalibrator::CheckIfHandPresent(cv::Mat input_image, HandDetectionType type)
-		{
-			std::vector<std::vector<cv::Point>> points;
-			cv::findContours(input_image, points, cv::RetrievalModes::RETR_LIST, cv::ContourApproximationModes::CHAIN_APPROX_SIMPLE);
-
-			if (points.size() == 0) return false;
-
-			for (int p = 0; p < points.size(); p++)
-			{
-				int area = cv::contourArea(points[p]);
-
-				if (type == handcalibration::HandDetectionType::MENU)
-					if (area > MIN_MENU_HAND_SIZE) return true;
-
-				if (type == handcalibration::HandDetectionType::GAME)
-					if (area > MIN_GAME_HAND_SIZE) return true;
-			}
-
-			return false;
-		}
-
-
-
-
-	}
-}

src/computervision/calibration/HandCalibrator.h

@@ -1,76 +0,0 @@
-#pragma once
-#include <opencv2/core/base.hpp>
-#include <opencv2/imgcodecs.hpp>
-#include <opencv2/imgproc.hpp>
-
-namespace computervision
-{
-	namespace handcalibration
-	{
-		enum class HandDetectionType
-		{
-			MENU,
-			GAME
-		};
-
-		class HandCalibrator
-		{
-		public:
-			HandCalibrator();
-
-			
-
-			/**
-			 * @brief draws the text to show the status of the calibration on the image
-			 *
-			 * @param output_frame the frame to draw on.
-			 */
-			void DrawHandCalibrationText(cv::Mat& output_frame);
-
-			/**
-			 * @brief sets the skin calibration variable.
-			 *
-			 * @param val the value to set
-			 */
-			void SetSkinCalibration(bool val);
-
-			/**
-			 * @brief sets the background calibration variable.
-			 *
-			 * @param val the value to set
-			 */
-			void SetBackGroundCalibrated(bool val);
-
-			/**
-			 * @brief sets the value for if the hand is present.
-			 * 
-			 * @param val the value to set.
-			 */
-			void SetHandPresent(bool val);
-
-			/**
-			 * @brief checks if the hand is present in the given image
-			 * 
-			 * @param input_image the input image to check.
-			 */
-			bool CheckIfHandPresent(cv::Mat input_image, HandDetectionType type);
-
-			/**
-			 * @brief sets the amount of fingers that are currently detected.
-			 * 
-			 * @param amount the amount of fingers.
-			 */
-			void SetAmountOfFingers(int amount);
-
-			void DrawBackgroundSkinCalibrated(cv::Mat& output_frame);
-
-		private:
-
-			bool background_calibrated;
-			bool skintone_calibrated;
-			bool hand_present;
-			int fingers_amount;
-		};
-
-	}
-}

src/gui/gui_element.h

@@ -5,6 +5,11 @@
 
 namespace gui
 {
+	//Represents the type of the entitie
+	enum class GuiType{
+		LABEL, BUTTON
+	};
+
 	/*
 	 * Structure for representing a gui item to display on the screen
 	 *
@@ -18,9 +23,12 @@ namespace gui
 		glm::vec2 position;
 		glm::vec2 scale;
 
+		virtual GuiType GetType() {
+			return GuiType::LABEL;
+		}
 		GuiTexture(int texture, glm::vec2 position, glm::vec2 scale): texture(texture), position(position), scale(scale)
 		{
-			scale.x /= (WINDOW_WIDTH / WINDOW_HEIGT);
+			scale.x /= (WINDOW_WIDTH / WINDOW_HEIGHT);
 		}
 	};
 }

src/gui/gui_interactable.cpp

@@ -2,6 +2,8 @@
 #include <GLFW/glfw3.h>
 #include "gui_interactable.h"
 
+#include <iostream>
+
 namespace gui
 {
 	InteractableGui::InteractableGui(int default_texture, glm::vec2 position, glm::vec2 scale)
@@ -41,14 +43,47 @@ namespace gui
 		}
 	}
 
+	void InteractableGui::ForceClick( int mouseButton)
+	{
+		if(mouseButton == GLFW_MOUSE_BUTTON_LEFT)
+		{
+			if (clicked_texture != 0)
+			{
+				texture = clicked_texture;
+			}
+			else
+			{
+				texture = default_texture;
+			}
+
+			if (!is_clicking)
+			{
+				OnClick();
+				is_clicking = true;
+			}
+		}
+		else
+		{
+			if (is_clicking)
+			{
+				is_clicking = false;
+			}
+		}
+		
+	}
+	
 	bool InteractableGui::IsHoveringAbove(GLFWwindow* window)
 	{
 		double x_pos, y_pos;
 		glfwGetCursorPos(window, &x_pos, &y_pos);
+		//std::cout << "Cursor pos in method: " << x_pos <<"::" <<  y_pos << std::endl;
 
 		const float x_rel = (x_pos / SCALED_WIDTH / DEFAULT_WIDTH) * 2.0f - 1.0f;
 		const float y_rel = -((y_pos / SCALED_HEIGHT / DEFAULT_HEIGHT) * 2.0f - 1.0f);
 
+		//std::cout << "x_rel And y_rel in method: " << x_rel << "::" << y_rel << std::endl;
+
+
 		if (x_rel >= minXY.x && x_rel <= maxXY.x &&
 			y_rel >= minXY.y && y_rel <= maxXY.y)
 		{

src/gui/gui_interactable.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <iostream>
 #include <glm/gtc/matrix_transform.hpp>
 #include "../toolbox/toolbox.h"
 #include "gui_element.h"
@@ -32,6 +33,14 @@ namespace gui
 		 */
 		void Update(GLFWwindow* window);
 
+		/*
+		 * @brief: Call this function when you want to perform a mouseclick
+		 *
+		 * @param mousebutton: mouseButton you want to perform the click on
+		 */
+		void ForceClick(int mouseButton);
+
+		
 		/*
 		 * @brief: This function gets called when the InteractabeGui is clicked
 		 */
@@ -50,7 +59,10 @@ namespace gui
 		/*
 		 * @brief: This function sets the texture of the InteractableGUI for when the InteractableGUI is clicked
 		 */
-		void SetClickedTexture(int texture) { clicked_texture = texture; }
+		void SetClickedTexture(int texture)
+		{
+			clicked_texture = texture;
+		}
 
 		/*
 		 * @brief: This function sets the texture of the InteractableGUI for when the mouse is hovering above the InteractableGUI
@@ -104,6 +116,10 @@ namespace gui
 		 */
 		void SetOnExitAction(void (*fun)()) { on_exit_action = fun; }
 
+		GuiType GetType() override {
+			return GuiType::BUTTON;
+		}
+
 	protected:
 		void OnClick() override { if (on_click_action != nullptr) on_click_action(); }
 		void OnEnter() override { if (on_enter_action != nullptr) on_enter_action(); }

src/main.cpp

@@ -1,14 +1,14 @@
 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <glm/gtc/matrix_transform.hpp>
-#include <functional>
-#include <vector>
 #define STB_IMAGE_IMPLEMENTATION
 #include <iostream>
 #include <map>
 
 #include "stb_image.h"
 #include <ostream>
+#include <stdlib.h>
+#include <iostream>
 
 #include <opencv2/core.hpp>
 #include <opencv2/videoio.hpp>
@@ -25,39 +25,22 @@
 #include "scenes/in_Game_Scene.h"
 #include "scenes/startup_Scene.h"
 
-#include "computervision/ObjectDetection.h"
-//#include "computervision/OpenPoseImage.h"
-#include "computervision/OpenPoseVideo.h"
-
-#include "computervision/async/async_arm_detection.h"
-
 #pragma comment(lib, "glfw3.lib")
 #pragma comment(lib, "glew32s.lib")
 #pragma comment(lib, "opengl32.lib")
 
 static double UpdateDelta();
 
-scene::Scene* current_scene;
-
 static GLFWwindow* window;
-bool points_img_available = false;
-cv::Mat points_img;
 
-void retrieve_points(std::vector<Point> arm_points, cv::Mat points_on_image)
+scene::Scene* current_scene;
-{
-
-	std::cout << "got points!!" << std::endl;
-	std::cout << "points: " << arm_points << std::endl;
-	points_img = points_on_image;
-	points_img_available = true;
-}
 
 int main(void)
 {
 #pragma region OPENGL_SETTINGS
 	if (!glfwInit())
 		throw "Could not inditialize glwf";
-	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGT, "SDBA", NULL, NULL);
+	window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "SDBA", NULL, NULL);
 	if (!window)
 	{
 		glfwTerminate();
@@ -82,6 +65,9 @@ int main(void)
         });
 
     bool window_open = true;
+
+	
+
 	// Main game loop
 	while (!glfwWindowShouldClose(window) && window_open)
 	{
@@ -100,14 +86,21 @@ int main(void)
                 current_scene = new scene::Startup_Scene();
                 break;
 
+		
             case scene::Scenes::INGAME:
                 current_scene = new scene::In_Game_Scene();
                 break;
-
+                
             default:
                 std::cout << "Wrong return value!!! ->" << std::endl;
                 break;
         }
+        
+		// Finish up
+		//shader.Stop();
+		glfwSwapBuffers(window);
+		glfwPollEvents();
+           
 	}
 
 	// Clean up -> preventing memory leaks!!!

src/renderEngine/Renderer.cpp

@@ -26,7 +26,7 @@ namespace render_engine
 			glCullFace(GL_BACK);
 			
 			const glm::mat4 projectionMatrix = 
-				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_HEIGT), NEAR_PLANE, FAR_PLANE);
+				glm::perspective(glm::radians(FOV), (WINDOW_WIDTH / WINDOW_HEIGHT), NEAR_PLANE, FAR_PLANE);
 
 			// Load the projectionmatrix into the shader
 			shader.Start();

src/scenes/in_Game_Scene.cpp

@@ -10,9 +10,6 @@
 #include "../renderEngine/renderer.h"
 #include "../shaders/entity_shader.h"
 #include "../toolbox/toolbox.h"
-#include <opencv2/core/base.hpp>
-#include "../computervision/HandDetectRegion.h"
-#include "../computervision/ObjectDetection.h"
 
 
 namespace scene
@@ -26,10 +23,6 @@ namespace scene
 	entities::Camera camera(glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
 	std::vector<gui::GuiTexture*> guis;
 
-
-	std::vector<computervision::HandDetectRegion> regions;
-	computervision::HandDetectRegion reg_left("left", 0, 0, 150, 150), reg_right("right", 0, 0, 150, 150), reg_up("up", 0, 0, 150, 150);
-
 	
 	In_Game_Scene::In_Game_Scene()
 	{
@@ -43,17 +36,6 @@ namespace scene
 
 	scene::Scenes scene::In_Game_Scene::start(GLFWwindow* window)
 	{
-		// set up squares according to size of camera input
-		cv::Mat camera_frame;
-		static_camera::getCap().read(camera_frame); // get camera frame to know the width and heigth
-		reg_left.SetXPos(10);
-		reg_left.SetYPos(camera_frame.rows / 2 - reg_left.GetHeight()/2);
-		reg_right.SetXPos(camera_frame.cols - 10 - reg_right.GetWidth());
-		reg_right.SetYPos(camera_frame.rows / 2 - reg_right.GetHeight()/2);
-		reg_up.SetXPos(camera_frame.cols / 2 - reg_up.GetWidth() / 2);
-		reg_up.SetYPos(10);
-
-
 		raw_model = render_engine::LoadObjModel("res/House.obj");
 		texture = { render_engine::loader::LoadTexture("res/Texture.png") };
 		texture.shine_damper = 10;
@@ -123,40 +105,14 @@ namespace scene
 	void scene::In_Game_Scene::update(GLFWwindow* window)
 	{
 		camera.Move(window);
-		update_hand_detection();
 	}
 
 	void scene::In_Game_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
 	{
 		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
 		{
-			cv::destroyWindow("camera");
 			return_value = scene::Scenes::STOP;
 		}
-
-		if (glfwGetKey(window, GLFW_KEY_B) == GLFW_PRESS)
-		{
-			reg_left.CalibrateBackground();
-			reg_right.CalibrateBackground();
-			reg_up.CalibrateBackground();
-		}
-
-		if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
-		{
-			std::vector<int> tresholds = reg_left.CalculateSkinTresholds();
-			reg_right.setSkinTresholds(tresholds);
-			reg_up.setSkinTresholds(tresholds);
-		}
 	}
 
-	void scene::In_Game_Scene::update_hand_detection()
-	{
-		cv::Mat camera_frame;
-		static_camera::getCap().read(camera_frame);
-		reg_left.DetectHand(camera_frame);
-		reg_right.DetectHand(camera_frame);
-		reg_up.DetectHand(camera_frame);
-
-		cv::imshow("camera", camera_frame);
-	}
 }

src/scenes/in_Game_Scene.h

@@ -8,7 +8,6 @@ namespace scene
 	{
 	private:
 		scene::Scenes return_value = scene::Scenes::INGAME;
-		void update_hand_detection();
 	
 	public:
 		In_Game_Scene();

src/scenes/startup_Scene.cpp

@@ -2,36 +2,183 @@
 #include <GLFW/glfw3.h>
 #include <map>
 #include "startup_Scene.h"
-#include "../computervision/ObjectDetection.h"
-#include "../computervision/HandDetectRegion.h"
 #include <iostream>
+#include <opencv2/core/mat.hpp>
+
+#include "../models/model.h"
+#include "../renderEngine/loader.h"
+#include "../renderEngine/obj_loader.h"
+#include "../renderEngine/renderer.h"
+#include "../shaders/entity_shader.h"
+#include "../gui/gui_interactable.h"
+#include "../toolbox/toolbox.h"
+#include "../computervision/MenuTest.h"
+#include "../computervision/ObjectDetection.h"
+
+
+
 
 namespace scene
 {
-	computervision::ObjectDetection objDetect;
+	shaders::GuiShader* gui_shader1;
+	std::vector<gui::GuiTexture*> guis1;
+
+	float item_number = 0;
+
+	bool hand_mode = false;
+
+	Startup_Scene::Startup_Scene() {
+		shaders::EntityShader shader;
+		shader.Init();
+		render_engine::renderer::Init(shader);
+		shader.CleanUp();
+
+		gui_shader1 = new shaders::GuiShader();
+		gui_shader1->Init();
+	}
+
+	gui::Button* ConvertGuiTextureToButton(gui::GuiTexture* texture) {
+		if (texture != NULL)
+			if (texture->GetType() == gui::GuiType::BUTTON) {
+				
+				gui::Button* button = (gui::Button*)texture;
+				return button;
+			}
+			else {
+				return NULL;
+			}
+	}
+
+	/*gui::InteractableGui* ConvertGuiTextureToInteractableGui(gui::GuiTexture* texture) {
+		if (texture != NULL)
+			if (texture->GetType() == gui::GuiType::BUTTON) {
+				return (gui::InteractableGui*)texture;
+			}
+			else {
+				return NULL;
+			}
+
+	}*/
+
+	gui::GuiTexture* GetMenuItem(bool hand_state) {
+		if(hand_state)
+		item_number += 0.20f;
+
+		int temp_item_number = item_number;
+		
+		//If temp_item_number is equal to the size of the array, set item_number bac to zero to loop through the array again
+		if (temp_item_number == guis1.size()) {
+			item_number = 0;
+			temp_item_number = 0;
+		}
+		std::cout << guis1[temp_item_number]->texture << std::endl;
+		return guis1[temp_item_number];
+	}
+
 	scene::Scenes scene::Startup_Scene::start(GLFWwindow *window)
 	{
+		// GUI stuff
+		gui::Button button_start(render_engine::loader::LoadTexture("res/menu_item_start1.png"), glm::vec2(0.0f, 0.6f), glm::vec2(0.25f, 0.25f));
+		button_start.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_start1_hover.png"));
+		button_start.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_start1_click.png"));
+		button_start.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Start!" << std::endl;
+				
+			});
+		guis1.push_back(&button_start);
+
+		gui::Button button_calibrate(render_engine::loader::LoadTexture("res/menu_item_calibrate1.png"), glm::vec2(0.0f, 0.0f), glm::vec2(0.25f, 0.25f));
+		button_calibrate.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_calibrate1_hover.png"));
+		button_calibrate.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_calibrate1_click.png"));
+		button_calibrate.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Calibrate!" << std::endl;
+
+			});
+		guis1.push_back(&button_calibrate);
+
+		gui::Button button_quit(render_engine::loader::LoadTexture("res/menu_item_quit1.png"), glm::vec2(0.0f, -0.6f), glm::vec2(0.25f, 0.25f));
+		button_quit.SetHoverTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_hover.png"));
+		button_quit.SetClickedTexture(render_engine::loader::LoadTexture("res/menu_item_quit1_click.png"));
+		button_quit.SetOnClickAction([]()
+			{
+				std::cout << "Clicked on button: Quit!" << std::endl;
+			});
+		guis1.push_back(&button_quit);
+
+		computervision::ObjectDetection objDetect;
+		cv::Mat cameraFrame;
+		gui::GuiTexture* chosen_item = NULL; //This is the selected menu_item
+		bool hand_closed = false; //Flag to prevent multiple button presses
+		
 		while (return_value == scene::Scenes::STARTUP)
 		{
 			render();
 			update(window);
+			
+			if (hand_mode) {
+				cameraFrame = objDetect.readCamera();
+
+				//Get hand state from camera
+				bool hand_detection = objDetect.detectHand(cameraFrame);
+
+				if (hand_detection)
+				{
+					hand_closed = false;
+					std::cout << "hand is opened" << std::endl;
+
+					//Loop through menu items
+					chosen_item = GetMenuItem(true);
+
+					gui::Button* new_button = ConvertGuiTextureToButton(chosen_item);
+					if (new_button != NULL) {
+						const float x_pos = (chosen_item->position.x + 1.0) * WINDOW_WIDTH / 2;
+						const float y_pos = (1.0 - chosen_item->position.y) * WINDOW_HEIGHT / 2;
+
+						//Set cursor to location of selected menu_item
+						glfwSetCursorPos(window, x_pos, y_pos);
+					}
+				}
+				else if (!hand_detection)
+				{
+					std::cout << "hand is closed" << std::endl;
+
+					//Gets selected menu_item
+					chosen_item = GetMenuItem(false);
+					gui::Button* new_button = ConvertGuiTextureToButton(chosen_item);
+
+					if (new_button != NULL && !hand_closed) {
+						//Run function click
+						new_button->ForceClick(GLFW_MOUSE_BUTTON_LEFT);
+						hand_closed = true;
+					}
+				}
+			}
 
 			glfwSwapBuffers(window);
 			glfwPollEvents();
 		}
-
+		gui_shader1->CleanUp();
+		render_engine::loader::CleanUp();
 		return return_value;
 	}
 
 	void scene::Startup_Scene::render() 
 	{
+		render_engine::renderer::Prepare();
 
+		// Render GUI items
+		render_engine::renderer::Render(guis1, *gui_shader1);
 	}
 
 	void scene::Startup_Scene::update(GLFWwindow* window)
 	{
-		bool hand_present;
+		for (gui::GuiTexture* button : guis1) {
-		objDetect.DetectHand(objDetect.ReadCamera(),hand_present);
+			gui::Button* new_button = ConvertGuiTextureToButton(button);
+			if (new_button != NULL)
+				new_button->Update(window);
+		}
 	}
 
 	void scene::Startup_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
@@ -39,7 +186,9 @@ namespace scene
 		if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS)
 		{
 			return_value = scene::Scenes::INGAME;
-			cv::destroyWindow("camera");
+		}
+		else if (glfwGetKey(window, GLFW_KEY_BACKSPACE) == GLFW_PRESS) {
+			hand_mode = !hand_mode;
 		}
 	}
 }

src/scenes/startup_Scene.h

@@ -1,6 +1,6 @@
 #pragma once
 #include "scene.h"
-#include <map>
+#include "../gui/gui_element.h"
 
 namespace scene
 {
@@ -12,9 +12,42 @@ namespace scene
 		scene::Scenes return_value = scene::Scenes::STARTUP;
 
 	public:
+		/**
+		 * @brief Constructor of the class Startup_Scene
+		 * 
+		 */
+		Startup_Scene();
+
+		/**
+		 * @brief 
+		 * 
+		 * @param window
+		 * @return 
+		 */
 		Scenes start(GLFWwindow* window) override;
+
+		/**
+		 * @brief 
+		 * 
+		 */
 		void render() override;
+
+		/**
+		 * @brief This method updates all the components on the window
+		 * 
+		 * @param window Window it updates
+		 */
 		void update(GLFWwindow* window) override;
+
+		/**
+		 * @brief Listener for key events
+		 * 
+		 * @param window Window it listens to for key events
+		 * @param key Key of event that is activated
+		 * @param scancode Code of Key
+		 * @param action 
+		 * @param mods
+		 */
 		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
 	};
 }

src/toolbox/toolbox.h

@@ -11,10 +11,10 @@ namespace toolbox
 
 		// Change these macros to change the window size
 		#define WINDOW_WIDTH 1400.0f
-		#define WINDOW_HEIGT 800.0f
+		#define WINDOW_HEIGHT 800.0f
 
 		#define SCALED_WIDTH (WINDOW_WIDTH/DEFAULT_WIDTH)
-		#define SCALED_HEIGHT (WINDOW_HEIGT/DEFAULT_HEIGHT)
+		#define SCALED_HEIGHT (WINDOW_HEIGHT/DEFAULT_HEIGHT)
 	//
 	
 	/*

wk2_fps.vcxproj

@@ -20,12 +20,10 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\collision\collision_handler.cpp" />
-    <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
-    <ClCompile Include="src\computervision\HandDetectRegion.cpp" />
     <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
-    <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
+    <ClCompile Include="src\computervision\FaceDetector.cpp" />
+    <ClCompile Include="src\computervision\MenuTest.cpp" />
     <ClCompile Include="src\computervision\ObjectDetection.cpp" />
-    <ClCompile Include="src\computervision\OpenPoseVideo.cpp" />
     <ClCompile Include="src\computervision\SkinDetector.cpp" />
     <ClCompile Include="src\computervision\FingerCount.cpp" />
     <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
@@ -46,16 +44,12 @@
   <ItemGroup>
     <ClInclude Include="src\collision\collision.h" />
     <ClInclude Include="src\collision\collision_handler.h" />
-    <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
-    <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
-    <ClInclude Include="src\computervision\HandDetectRegion.h" />
     <ClInclude Include="src\scenes\in_Game_Scene.h" />
     <ClInclude Include="src\scenes\scene.h" />
-    <ClInclude Include="src\computervision\async\async_arm_detection.h" />
+    <ClInclude Include="src\computervision\FaceDetector.h" />
-    <ClInclude Include="src\computervision\async\StaticCameraInstance.h" />
     <ClInclude Include="src\computervision\FingerCount.h" />
     <ClInclude Include="src\computervision\BackgroundRemover.h" />
-    <ClInclude Include="src\computervision\OpenPoseVideo.h" />
+    <ClInclude Include="src\computervision\MenuTest.h" />
     <ClInclude Include="src\computervision\SkinDetector.h" />
     <ClInclude Include="src\computervision\ObjectDetection.h" />
     <ClInclude Include="src\entities\camera.h" />
@@ -79,12 +73,6 @@
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />
   </ItemGroup>
-  <ItemGroup>
-    <None Include="..\..\Avans Hogeschool\Kim Veldhoen - Proftaak 2.4\pose_iter_160000.caffemodel" />
-    <None Include="res\pose\coco\pose_deploy_linevec.prototxt" />
-    <None Include="res\pose\mpi\pose_deploy_linevec_faster_4_stages.prototxt" />
-    <None Include="res\pose\mpi\pose_iter_160000.caffemodel" />
-  </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>16.0</VCProjectVersion>
     <ProjectGuid>{A7ECF1BE-DB22-4BF7-BFF6-E3BF72691EE6}</ProjectGuid>
@@ -153,8 +141,6 @@
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);;C:\opencv\opencv\build\include;C:\opencv\build\include</IncludePath>
     <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib;C:\opencv\build\x64\vc15\lib</LibraryPath>
-    <IncludePath>C:\opencv\build\include\;$(VC_IncludePath);$(WindowsSDK_IncludePath);C:\opencv\opencv\build\include</IncludePath>
-    <LibraryPath>C:\opencv\build\x64\vc15\lib;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);C:\opencv\opencv\build\x64\vc15\lib</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -228,7 +214,6 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalLibraryDirectories>$(SolutionDir)lib\glfw-3.3.2\$(Platform);$(SolutionDir)lib\glew-2.1.0\lib\Release\$(Platform);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies); opencv_world452.lib;opencv_world452d.lib</AdditionalDependencies>
-      <AdditionalDependencies>opencv_world452.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

wk2_fps.vcxproj.filters

@@ -1,70 +1,168 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <ClCompile Include="src\collision\collision_handler.cpp" />
+    <Filter Include="Source Files">
-    <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-    <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
+      <Extensions>cpp;c;cc;cxx;c++;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    <ClCompile Include="src\computervision\ObjectDetection.cpp" />
+    </Filter>
-    <ClCompile Include="src\computervision\OpenPoseVideo.cpp" />
+    <Filter Include="Header Files">
-    <ClCompile Include="src\computervision\SkinDetector.cpp" />
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-    <ClCompile Include="src\computervision\FingerCount.cpp" />
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
-    <ClCompile Include="src\computervision\BackgroundRemover.cpp" />
+    </Filter>
-    <ClCompile Include="src\entities\camera.cpp" />
+    <Filter Include="Resource Files">
-    <ClCompile Include="src\entities\collision_entity.cpp" />
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-    <ClCompile Include="src\entities\entity.cpp" />
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    <ClCompile Include="src\gui\gui_interactable.cpp" />
+    </Filter>
-    <ClCompile Include="src\main.cpp" />
-    <ClCompile Include="src\renderEngine\loader.cpp" />
-    <ClCompile Include="src\renderEngine\obj_loader.cpp" />
-    <ClCompile Include="src\renderEngine\renderer.cpp" />
-    <ClCompile Include="src\shaders\gui_shader.cpp" />
-    <ClCompile Include="src\shaders\shader_program.cpp" />
-    <ClCompile Include="src\shaders\entity_shader.cpp" />
-    <ClCompile Include="src\toolbox\toolbox.cpp" />
-    <ClCompile Include="src\scenes\startup_Scene.cpp" />
-    <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
-    <ClCompile Include="src\computervision\HandDetectRegion.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\collision\collision.h" />
+    <ClCompile Include="src\entities\Camera.cpp">
-    <ClInclude Include="src\collision\collision_handler.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\scenes\in_Game_Scene.h" />
+    </ClCompile>
-    <ClInclude Include="src\scenes\scene.h" />
+    <ClCompile Include="src\entities\Entity.cpp">
-    <ClInclude Include="src\computervision\async\async_arm_detection.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\computervision\async\StaticCameraInstance.h" />
+    </ClCompile>
-    <ClInclude Include="src\computervision\FingerCount.h" />
+    <ClCompile Include="src\renderEngine\Loader.cpp">
-    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\computervision\OpenPoseVideo.h" />
+    </ClCompile>
-    <ClInclude Include="src\computervision\SkinDetector.h" />
+    <ClCompile Include="src\renderEngine\Renderer.cpp">
-    <ClInclude Include="src\computervision\ObjectDetection.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\entities\camera.h" />
+    </ClCompile>
-    <ClInclude Include="src\entities\collision_entity.h" />
+    <ClCompile Include="src\main.cpp">
-    <ClInclude Include="src\entities\entity.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\entities\light.h" />
+    </ClCompile>
-    <ClInclude Include="src\gui\gui_element.h" />
+    <ClCompile Include="src\shaders\shader_program.cpp">
-    <ClInclude Include="src\gui\gui_interactable.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\models\model.h" />
+    </ClCompile>
-    <ClInclude Include="src\renderEngine\loader.h" />
+    <ClCompile Include="src\renderEngine\obj_loader.cpp">
-    <ClInclude Include="src\renderEngine\obj_loader.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\renderEngine\renderer.h" />
+    </ClCompile>
-    <ClInclude Include="src\shaders\gui_shader.h" />
+    <ClCompile Include="src\toolbox\toolbox.cpp">
-    <ClInclude Include="src\shaders\shader_program.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\shaders\entity_shader.h" />
+    </ClCompile>
-    <ClInclude Include="src\stb_image.h" />
+    <ClCompile Include="src\shaders\entity_shader.cpp">
-    <ClInclude Include="src\toolbox\Timer.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\toolbox\toolbox.h" />
+    </ClCompile>
-    <ClInclude Include="src\scenes\startup_Scene.h" />
+    <ClCompile Include="src\shaders\gui_shader.cpp">
-    <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
+      <Filter>Source Files</Filter>
-    <ClInclude Include="src\computervision\HandDetectRegion.h" />
+    </ClCompile>
-    <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
+    <ClCompile Include="src\gui\gui_interactable.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\in_Game_Scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\scenes\startup_Scene.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\entities\collision_entity.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\collision\collision_handler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\ObjectDetection.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\SkinDetector.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\FingerCount.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\FaceDetector.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\BackgroundRemover.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\computervision\MenuTest.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="src\entities\Camera.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\entities\Entity.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\models\Model.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\renderEngine\Loader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\renderEngine\Renderer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\stb_image.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\shaders\shader_program.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\renderEngine\obj_loader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\toolbox\toolbox.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\entities\light.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\shaders\entity_shader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\shaders\gui_shader.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\gui\gui_element.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\gui\gui_interactable.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\in_Game_Scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\scenes\startup_Scene.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\entities\collision_entity.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\collision\collision.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\collision\collision_handler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\ObjectDetection.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\SkinDetector.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\FingerCount.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\FaceDetector.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\BackgroundRemover.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\toolbox\Timer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\computervision\MenuTest.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />
   </ItemGroup>
-  <ItemGroup>
-    <None Include="..\..\Avans Hogeschool\Kim Veldhoen - Proftaak 2.4\pose_iter_160000.caffemodel" />
-    <None Include="res\pose\coco\pose_deploy_linevec.prototxt" />
-    <None Include="res\pose\mpi\pose_deploy_linevec_faster_4_stages.prototxt" />
-    <None Include="res\pose\mpi\pose_iter_160000.caffemodel" />
-  </ItemGroup>
 </Project>