[ADD] comments

src/collision/collision_handler.cpp

@@ -3,7 +3,7 @@
 
 namespace collision
 {
-	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>>& entities)
+	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>> entities)
 	{
 		if (entities.size() < 2) { return; }
 			if (entities.size() == 2)

src/collision/collision_handler.h

@@ -13,5 +13,5 @@ namespace collision
 	 *
 	 * @param entities: A list with all the collision entities.
 	 */
-	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>>& entities);
+	void CheckCollisions(std::vector<std::shared_ptr<entities::CollisionEntity>> entities);
 }

src/computervision/async/StaticCameraInstance.h

@@ -6,7 +6,7 @@ namespace static_camera
 
 	static cv::VideoCapture getCap()
 	{
-		static cv::VideoCapture cap(1);
+		static cv::VideoCapture cap(0);
 		return cap;
 	}
 };

src/computervision/background_remover.cpp

@@ -1,4 +1,4 @@
-#include "BackgroundRemover.h"
+#include "background_remover.h"
 
 /*
  Author: Pierfrancesco Soffritti https://github.com/PierfrancescoSoffritti

src/computervision/finger_count.cpp

@@ -1,4 +1,4 @@
-#include "FingerCount.h"
+#include "finger_count.h"
 
 #include "opencv2/imgproc.hpp"
 #include "opencv2/highgui.hpp"

src/computervision/hand_detect_region.cpp

@@ -1,6 +1,6 @@
 
-#include "HandDetectRegion.h"
-
+#include "hand_detect_region.h"
+#define TIME_DURATION 1.0f
 namespace computervision
 {
 
@@ -20,6 +20,15 @@ namespace computervision
 		Mat input_frame = GenerateHandMaskSquare(camera_frame);
 		frame_out = input_frame.clone();
 
+		if (!background_calibrated || !skin_calibrated)
+			if (time >= TIME_DURATION)
+			{
+				//std::cout << "timer finised,  seconds left: " << seconds_left << std::endl;
+				seconds_left--;
+				time = 0;
+			}
+		
+
 		// detect skin color
 		skin_detector.drawSkinColorSampler(camera_frame,start_x_pos,start_y_pos,region_width,region_height);
 
@@ -32,6 +41,29 @@ namespace computervision
 		// draw the hand rectangle on the camera input, and draw text showing if the hand is open or closed.
 		DrawHandMask(&camera_frame);
 
+		if (seconds_left <= 0)
+		{
+			if (!background_calibrated)
+			{
+				background_remover.calibrate(input_frame);
+				background_calibrated = true;
+				hand_calibrator.SetBackGroundCalibrated(background_calibrated);
+				seconds_left = 5;
+				time = 0;
+			}
+			else
+			{
+
+				if (!skin_calibrated)
+				{
+					if (is_main_skin_detection_region)
+						skin_timer_callback();
+				}
+			}
+
+		}
+
+		// uncomment these lines to show debug hand information
 		//imshow("output" + region_id, frame_out);
 		//imshow("foreground" + region_id, foreground);
 		//imshow("handMask" + region_id, handMask);
@@ -47,7 +79,17 @@ namespace computervision
 
 		hand_calibrator.DrawBackgroundSkinCalibrated(camera_frame);
 
-
+		std::string calibration_text = (!background_calibrated ? "calibrating background in " : (!skin_calibrated ? "calibrating skin in " : ""));
+		calibration_text += std::to_string(seconds_left);
+		if (!background_calibrated || !skin_calibrated)
+		{
+			cv::rectangle(camera_frame, cv::Rect(0, camera_frame.rows - 130, 600, 60), cv::Scalar(0, 0, 0), -1);
+			cv:putText(camera_frame, calibration_text, cv::Point(5, 400), cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(255, 0, 255), 2);
+		}
+		if (background_calibrated && !skin_calibrated)
+		{
+			cv::putText(camera_frame, "put your hand in the left square", cv::Point(5, camera_frame.rows - 105), cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(255, 0, 255), 2);
+		}
 
 	}
 
@@ -92,6 +134,8 @@ namespace computervision
 	{
 		std::cout << "calibrating skin " << region_id << std::endl;
 		hand_calibrator.SetSkinCalibration(true);
+		skin_calibrated = true;
+		time = 0;
 		return skin_detector.calibrateAndReturn(frame_out);
 	}
 
@@ -100,6 +144,13 @@ namespace computervision
 		std::cout << "setting skin " << region_id << std::endl;
 		skin_detector.setTresholds(tresholds);
 		hand_calibrator.SetSkinCalibration(true);
+		skin_calibrated = true;
+		time = 0;
+	}
+
+	void HandDetectRegion::UpdateTime(float delta_time)
+	{
+		time += delta_time;
 	}
 
 }

src/computervision/hand_detect_region.h

@@ -2,11 +2,13 @@
 
 #include <opencv2/core.hpp>
 #include <opencv2/imgproc.hpp>
+#include <GLFW/glfw3.h>
+
 #include "async/StaticCameraInstance.h"
 #include "calibration/HandCalibrator.h"
-#include "BackgroundRemover.h"
-#include "SkinDetector.h"
-#include "FingerCount.h"
+#include "background_remover.h"
+#include "skin_detector.h"
+#include "finger_count.h"
 namespace computervision
 {
 	class HandDetectRegion
@@ -36,8 +38,12 @@ namespace computervision
 		std::vector<int> CalculateSkinTresholds();
 
 		void setSkinTresholds(std::vector<int>& tresholds);
+		void UpdateTime(float delta_time);
+		void SetMainSkinDetecRegion(bool val) { is_main_skin_detection_region = val; };
+		void SetSkinTimerCallback(std::function<void()> fun) { skin_timer_callback = fun; };
 
 	private:
+
 		int start_x_pos;
 		int start_y_pos;
 		int region_height;
@@ -51,6 +57,17 @@ namespace computervision
 		std::string region_id;
 
 		bool DrawHandMask(cv::Mat* input);
+
+		float time = 0;
+		int seconds_left = 5; // calibration countdown
+
+		bool background_calibrated = false;
+		bool skin_calibrated = false;
+		bool is_main_skin_detection_region = false;
+		std::function<void()> skin_timer_callback;
+
+
+		
 	};
 
 }

src/computervision/object_detection.cpp

@@ -1,14 +1,7 @@
 
-#include <opencv2/videoio.hpp>
-#include <opencv2/highgui.hpp>
-#include <opencv2/video.hpp>
+#include "object_detection.h"
 
-#include "ObjectDetection.h"
-#include "BackgroundRemover.h"
-#include "SkinDetector.h"
-#include "FingerCount.h"
-#include "async/StaticCameraInstance.h"
-#include "calibration/HandCalibrator.h"
+#define TIME_DURATION 1.0f
 
 namespace computervision
 {
@@ -25,6 +18,11 @@ namespace computervision
 	handcalibration::HandCalibrator hand_calibrator;
 
 	cv::VideoCapture cap = static_camera::getCap();
+	float time = 0;
+	int seconds_left = 5; // calibration countdown
+
+	bool background_calibrated = false;
+	bool skin_calibrated = false;
 
 	ObjectDetection::ObjectDetection()
 	{
@@ -42,6 +40,20 @@ namespace computervision
 
 	bool ObjectDetection::DetectHand(Mat camera_frame, bool& hand_present)
 	{
+		//calculate deltatime
+		if (!background_calibrated || !skin_calibrated)
+		{
+			UpdateTime();
+
+			if (time >= TIME_DURATION)
+			{
+				std::cout << "timer finised,  seconds left: " << seconds_left << std::endl;
+				seconds_left--;
+				time = 0;
+			}
+		}
+
+
 		Mat input_frame = GenerateHandMaskSquare(camera_frame);
 		frame_out = input_frame.clone();
 
@@ -63,37 +75,58 @@ namespace computervision
 		// draw the hand rectangle on the camera input, and draw text showing if the hand is open or closed.
 		DrawHandMask(&camera_frame);
 
+		if (seconds_left <= 0)
+		{
+			if (!background_calibrated)
+			{
+				background_remover.calibrate(input_frame);
+				background_calibrated = true;
+				hand_calibrator.SetBackGroundCalibrated(background_calibrated);
+				seconds_left = 5;
+				time = 0;
+			}
+			else
+			{
+
+				if (!skin_calibrated)
+				{
+					skin_detector.calibrate(input_frame);
+					skin_calibrated = true;
+					hand_calibrator.SetSkinCalibration(skin_calibrated);
+					time = 0;
+				}
+			}
+
+		}
 
 		hand_calibrator.SetAmountOfFingers(fingers_amount);
 		finger_count.DrawHandContours(camera_frame);
 		hand_calibrator.DrawHandCalibrationText(camera_frame);
+
+		std::string calibration_text = (!background_calibrated ? "calibrating background in " : (!skin_calibrated ? "calibrating skin in " : ""));
+		calibration_text += std::to_string(seconds_left);
+		if (!background_calibrated || !skin_calibrated)
+		{
+			cv::rectangle(camera_frame, cv::Rect(0, camera_frame.rows - 120, 500, 50), cv::Scalar(0, 0, 0), -1);
+			cv::putText(camera_frame, calibration_text, cv::Point(5, camera_frame.rows-80), cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(255, 0, 255), 2);
+		}
+
+		if (background_calibrated && !skin_calibrated)
+		{
+			cv::putText(camera_frame, "put your hand in the square", cv::Point(5, camera_frame.rows - 100), cv::FONT_HERSHEY_COMPLEX, 1.0, cv::Scalar(255, 0, 255), 2);
+		}
 		imshow("camera", camera_frame);
 
+		// uncomment these lines to show debug hand information
 		/*imshow("output", frame_out);
 		imshow("foreground", foreground);
 		imshow("handMask", handMask);
 		imshow("handDetection", fingerCountDebug);*/
 
-		hand_present = hand_calibrator.CheckIfHandPresent(handMask,handcalibration::HandDetectionType::MENU);
+		hand_present = hand_calibrator.CheckIfHandPresent(handMask, handcalibration::HandDetectionType::MENU);
 		hand_calibrator.SetHandPresent(hand_present);
 
 
-
-		int key = waitKey(1);
-
-		if (key == 98) // b, calibrate the background
-		{
-			background_remover.calibrate(input_frame);
-			hand_calibrator.SetBackGroundCalibrated(true);
-		}
-		else if (key == 115) // s, calibrate the skin color
-		{
-			skin_detector.calibrate(input_frame);
-			hand_calibrator.SetSkinCalibration(true);
-
-		}
-
-
 		return fingers_amount > 0;
 	}
 
@@ -144,5 +177,15 @@ namespace computervision
 		imshow("Webcam image", img);
 	}
 
+	void ObjectDetection::UpdateTime()
+	{
+		double current_time = glfwGetTime();
+		static double last_frame_time = current_time;
+		double delt_time = current_time - last_frame_time;
+		last_frame_time = current_time;
+
+		time += delt_time;
+	}
+
 
 }

src/computervision/object_detection.h

@@ -8,6 +8,14 @@
 #include <opencv2/core.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/highgui/highgui.hpp>
+#include <opencv2/video.hpp>
+#include <GLFW/glfw3.h>
+
+#include "background_remover.h"
+#include "skin_detector.h"
+#include "finger_count.h"
+#include "async/StaticCameraInstance.h"
+#include "calibration/HandCalibrator.h"
 
 
 namespace computervision
@@ -86,6 +94,7 @@ namespace computervision
 	private:
 		bool is_hand_open;
 		bool is_hand_present;
+		void UpdateTime();
 
 	};
 

src/computervision/skin_detector.cpp

@@ -1,4 +1,4 @@
-#include "SkinDetector.h"
+#include "skin_detector.h"
 #include <iostream>
 
 /*

src/entities/collision_entity.cpp

@@ -40,10 +40,7 @@ namespace entities
 		
 		const glm::vec3 size = bounding_box.size;
 
-		min_xyz = { bounding_box.center_pos.x - (0.5 * size.x), bounding_box.center_pos.y, bounding_box.center_pos.z - (0.5 * size.z) };
-		max_xyz = { bounding_box.center_pos.x + (0.5 * size.x), bounding_box.center_pos.y + size.y, bounding_box.center_pos.z + (0.5 * size.z) };
-
-		// min_xyz = bounding_box.center_pos;
-		// max_xyz = { bounding_box.center_pos.x + size.x, bounding_box.center_pos.y + size.y, bounding_box.center_pos.z + size.z };
+		min_xyz = bounding_box.center_pos;
+		max_xyz = glm::vec3(min_xyz.x + size.x, min_xyz.y + size.y, min_xyz.z + size.z);
 	}
 }

src/entities/collision_entity.h

@@ -58,7 +58,7 @@ namespace entities
 		void SetCollisionBehaviour(std::function<void(const collision::Collision&)> function)
 		{ if (function != nullptr) { on_collide = function; } }
 
-	public:
+	protected:
 
 		/*
 		 * @brief: This method moves the collision to the center of the entity

src/entities/house_generator.cpp

@@ -20,76 +20,71 @@ namespace entities
 		GenerateFurnitureModels();
 	}
 
-	std::deque<std::shared_ptr<CollisionEntity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
+	std::deque<std::shared_ptr<Entity>> HouseGenerator::GenerateHouse(const glm::vec3& position, float y_rotation)
 	{
-		std::deque<std::shared_ptr<CollisionEntity>> furniture;
+		std::deque<std::shared_ptr<Entity>> furniture;
 
 		// Add house
-		collision::Box house_box = { position, glm::vec3(0,0,0) };
-		furniture.push_front(std::make_shared<CollisionEntity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE, house_box));
-
-		// for(int i = 0; i<toolbox::Random(1,4);i++)
-		// {
-		// 	FurnitureType type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
-		// 	models::TexturedModel model = GetFurnitureModel(type);
-		// 	glm::vec3 model_pos = glm::vec3(position.x, position.y, position.z);
-		// 	collision::Box model_box = { model_pos, model.raw_model.model_size };
-		// 	model_box.SetRotation(-90);
-		// 	furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
-		// 	//furniture_collision.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
-		// 	
-		// }
-
-		//furniture_collision.pop_front();
+		furniture.push_front(std::make_shared<Entity>(house_model, position, glm::vec3(0, y_rotation, 0), HOUSE_SIZE));
 
+		for(int i = 0; i<toolbox::Random(1,4);i++)
+		{
+			FurnitureType type = FurnitureType(toolbox::Random(0, furniture_models.size() - 1));
+			models::TexturedModel model = GetFurnitureModel(type);
+			glm::vec3 model_pos = glm::vec3(position.x, position.y, position.z);
+			collision::Box model_box = { model_pos, model.raw_model.model_size };
+			model_box.SetRotation(-90);
+			furniture.push_back(std::make_shared<CollisionEntity>(model, model_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, model_box));
+		}
 		
+		/*
 		// Add furniture
-		 // models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
-		 // glm::vec3 couch_pos = glm::vec3(position.x + 200, position.y, position.z + 10);
-		 // collision::Box couch_box = { couch_pos, couch.raw_model.model_size * (HOUSE_SIZE) };
-		 // couch_box.SetRotation(-90);
-		 // furniture.push_back(std::make_shared<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
-		 //
-		 // models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
-		 // glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
-		 // collision::Box table_box = { table_pos, table.raw_model.model_size * ((HOUSE_SIZE) * 1.3f) };
-		 // furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
-		 //
-		 // models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
-		 // glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		 // collision::Box chair_box = { chair_pos, chair.raw_model.model_size * (HOUSE_SIZE) };
-		 // furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
-		 //
-		 // models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
-		 // glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		 // collision::Box plant_box = { plant_pos, plant.raw_model.model_size * (HOUSE_SIZE) };
-		 // furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
-		 //
-		 // models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
-		 // glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		 // collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size * (HOUSE_SIZE) };
-		 // furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
-		 //
-		 // models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
-		 // glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		 // collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size * (HOUSE_SIZE) };
-		 // furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
-		 //
-		 // models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
-		 // glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		 // collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size * (HOUSE_SIZE) };
-		 // furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
-		 //
-		 // models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
-		 // glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
-		 // collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size * (HOUSE_SIZE / 2) };
-		 // furniture.push_back(std::make_shared<CollisionEntity>(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box));
+		models::TexturedModel couch = GetFurnitureModel(FurnitureType::COUCH);
+		glm::vec3 couch_pos = glm::vec3(position.x + 200, position.y, position.z + 10);
+		collision::Box couch_box = { couch_pos, couch.raw_model.model_size };
+		couch_box.SetRotation(-90);
+		furniture.push_back(std::make_shared<CollisionEntity>(couch, couch_pos, glm::vec3(0, -90, 0), HOUSE_SIZE * 2, couch_box));
+
+		models::TexturedModel table = GetFurnitureModel(FurnitureType::TABLE);
+		glm::vec3 table_pos = glm::vec3(position.x - 30, position.y, position.z);
+		collision::Box table_box = { table_pos, table.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(table, table_pos, glm::vec3(0, 0, 0), HOUSE_SIZE * 1.3, table_box));
+
+		models::TexturedModel chair = GetFurnitureModel(FurnitureType::CHAIR);
+		glm::vec3 chair_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box chair_box = { chair_pos, chair.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(chair, chair_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, chair_box));
+
+		models::TexturedModel plant = GetFurnitureModel(FurnitureType::PLANT);
+		glm::vec3 plant_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box plant_box = { plant_pos, plant.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(plant, plant_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, plant_box));
+
+		models::TexturedModel guitar = GetFurnitureModel(FurnitureType::GUITAR);
+		glm::vec3 guitar_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box guitar_box = { guitar_pos, guitar.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(guitar, guitar_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, guitar_box));
+		
+		models::TexturedModel bookshelf = GetFurnitureModel(FurnitureType::BOOKSHELF);
+		glm::vec3 bookshelf_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box bookshelf_box = { bookshelf_pos, bookshelf.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(bookshelf, bookshelf_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, bookshelf_box));
+
+		models::TexturedModel lamp = GetFurnitureModel(FurnitureType::LAMP);
+		glm::vec3 lamp_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box lamp_box = { lamp_pos, lamp.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(lamp, lamp_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, lamp_box));
+
+		models::TexturedModel ceiling_object = GetFurnitureModel(FurnitureType::CEILING_OBJECTS);
+		glm::vec3 ceiling_object_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box ceiling_object_box = { ceiling_object_pos, ceiling_object.raw_model.model_size };
+		furniture.push_back(std::make_shared<CollisionEntity>(ceiling_object, ceiling_object_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, ceiling_object_box));
 
 		models::TexturedModel misc = GetFurnitureModel(FurnitureType::MISC);
-		glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y - 10, position.z + 220);
-		collision::Box misc_box = { misc_pos, misc.raw_model.model_size * (HOUSE_SIZE) };
+		glm::vec3 misc_pos = glm::vec3(position.x - 50, position.y, position.z + 220);
+		collision::Box misc_box = { misc_pos, misc.raw_model.model_size };
 		furniture.push_back(std::make_shared<CollisionEntity>(misc, misc_pos, glm::vec3(0, 0, 0), HOUSE_SIZE, misc_box));
-		
+		*/
 		return furniture;
 	}
 
@@ -260,9 +255,4 @@ namespace entities
 
 		furniture_models.insert(std::pair<FurnitureType, std::deque<models::TexturedModel>>(FurnitureType::MISC, miscs));
 	}
-
-	/*std::deque<std::shared_ptr<CollisionEntity>> HouseGenerator::GetFurnitureCollisions() 
-	{
-		return furniture_collision;
-	}*/
 }

src/entities/house_generator.h

@@ -5,7 +5,6 @@
 #include <map>
 #include "../models/Model.h"
 #include "../collision/collision.h"
-#include "collision_entity.h"
 
 namespace entities
 {
@@ -31,8 +30,6 @@ namespace entities
 		models::ModelTexture default_texture;
 		
 		std::map<FurnitureType, std::deque<models::TexturedModel>> furniture_models;
-		//std::deque<std::shared_ptr<CollisionEntity>> furniture_collision;
-
 
 	public:
 		HouseGenerator();
@@ -45,17 +42,12 @@ namespace entities
 		 *
 		 * @return: A list with all the entities of the generated house (the furniture)
 		 */
-		std::deque<std::shared_ptr<CollisionEntity>> GenerateHouse(const glm::vec3& position, float y_rotation);
+		std::deque<std::shared_ptr<Entity>> GenerateHouse(const glm::vec3& position, float y_rotation);
 
 		/*
 		 * @brief: Returns the depth of the house (chunk)
 		 */
-		float GetHouseDepth() const { return house_model.raw_model.model_size.x * HOUSE_SIZE; 
-		
-		}
-
-		//std::deque<std::shared_ptr<CollisionEntity>> GetFurnitureCollisions();
-
+		float GetHouseDepth() const { return house_model.raw_model.model_size.x * HOUSE_SIZE; }
 	
 	private:
 		/*

src/entities/main_character.cpp

@@ -22,7 +22,7 @@ namespace entities
 	void MainCharacter::Move(GLFWwindow* window)
 	{
 		if (is_playing) {
-			movement_speed = -2.0f;	//Forward speed adjustment, bee is moving at a standard speedrate
+			movement_speed = -0.5f;	//Forward speed adjustment, bee is moving at a standard speedrate
 			down_speed = -1.0f;		//Down speed adjustment, downspeed is difference between down_speed and UP_SPEED	
 			side_speed = 0;			//Side speed adjustment
 
@@ -97,8 +97,4 @@ namespace entities
 		is_playing = false;
 		std::cout << "collision" << std::endl;
 	}
-
-	bool MainCharacter::GetOnCollide() {
-		return is_playing;
-	}
 }

src/entities/main_character.h

@@ -34,7 +34,5 @@ namespace entities
 		void Move(GLFWwindow* window);
 
 		void OnCollide(const collision::Collision& collision) override;
-	
-		bool GetOnCollide();
 	};
 }

src/main.cpp

@@ -27,10 +27,8 @@
 #include "scenes/scene.h"
 #include "scenes/in_Game_Scene.h"
 #include "scenes/startup_Scene.h"
-#include "scenes/game_Over_Scene.h"
-#include "entities/collision_entity.h"
 
-#include "computervision/ObjectDetection.h"
+#include "computervision/object_detection.h"
 //#include "computervision/OpenPoseImage.h"
 #include "computervision/OpenPoseVideo.h"
 
@@ -114,10 +112,6 @@ int main(void)
                 current_scene = new scene::In_Game_Scene();
                 break;
                 
-            case scene::Scenes::GAMEOVER:
-                current_scene = new scene::Game_Over_Scene();
-                break;
-
             default:
                 std::cout << "Wrong return value!!! ->" << std::endl;
                 break;

src/scenes/game_Over_Scene.cpp

@@ -1,184 +0,0 @@
-#include <iostream>
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
-#include <map>
-#include "game_Over_Scene.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"
-#include "../computervision/HandDetectRegion.h"
-
-namespace scene
-{
-	shaders::GuiShader* gui_shader_gameOver;
-	std::vector<gui::GuiTexture*> guis_gameOver;
-	computervision::ObjectDetection objDetect_gameOver;
-
-	float item_number_gameOver = 0;
-
-	bool hand_mode_gameOver = false;
-
-	Game_Over_Scene::Game_Over_Scene() 
-	{
-		shaders::EntityShader shader;
-		shader.Init();
-		render_engine::renderer::Init(shader);
-		shader.CleanUp();
-
-		gui_shader_gameOver = new shaders::GuiShader();
-		gui_shader_gameOver->Init();
-	}
-
-	gui::Button* ConvertGuiTextureToButtonGameOver(gui::GuiTexture* texture) {
-		gui::Button* button;
-		if (texture != NULL)
-		{
-
-			if (texture->GetType() == gui::GuiType::BUTTON) {
-
-				button = (gui::Button*)texture;
-				return button;
-			}
-			else {
-				button = nullptr;
-				return button;
-			}
-		}
-		else {
-			button = nullptr;
-			return button;
-		}
-	}
-
-	gui::GuiTexture* GetMenuItemGameOver(bool hand_state) {
-		if (hand_state)
-			item_number_gameOver += 0.20f;
-
-		int temp_item_number = item_number_gameOver;
-
-		//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 == guis_gameOver.size()) {
-			item_number_gameOver = 0;
-			temp_item_number = 0;
-		}
-		std::cout << guis_gameOver[temp_item_number]->texture << std::endl;
-		return guis_gameOver[temp_item_number];
-	}
-
-	scene::Scenes scene::Game_Over_Scene::start(GLFWwindow* window) {
-		gui::Button button_start_scene(render_engine::loader::LoadTexture("res/Birb1.jpg"), glm::vec2(0.0f, 0.6f), glm::vec2(0.25f, 0.25f));
-		button_start_scene.SetHoverTexture(render_engine::loader::LoadTexture("res/Birb2.jpg"));
-		button_start_scene.SetClickedTexture(render_engine::loader::LoadTexture("res/Birb3.jpg"));
-		button_start_scene.SetOnClickAction([]()
-			{
-				std::cout << "Back to start screen!!" << std::endl;
-			});
-		guis_gameOver.push_back(&button_start_scene);
-	
-		computervision::ObjectDetection objDetect;
-		cv::Mat cameraFrame;
-		gui::GuiTexture* chosen_item_gameOver = NULL; //This is the selected menu_item
-		bool hand_closed = false; //Flag to prevent multiple button presses
-
-		while (return_value == scene::Scenes:: GAMEOVER)
-		{
-			render();
-			update(window);
-
-			if (hand_mode_gameOver) 
-			{
-				cameraFrame = objDetect_gameOver.ReadCamera();
-
-				bool detect = false;
-				bool hand_detection = objDetect_gameOver.DetectHand(cameraFrame, detect);
-
-				if (hand_detection) 
-				{
-					hand_closed = false;
-					std::cout << "hand is opened" << std::endl;
-
-					//Loop through menu items
-					chosen_item_gameOver = GetMenuItemGameOver(true);
-
-					gui::Button* new_button = ConvertGuiTextureToButtonGameOver(chosen_item_gameOver);
-					if (new_button != NULL) {
-						const float x_pos = (chosen_item_gameOver->position.x + 1.0) * WINDOW_WIDTH / 2;
-						const float y_pos = (1.0 - chosen_item_gameOver->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_gameOver = GetMenuItemGameOver(false);
-					gui::Button* new_button = ConvertGuiTextureToButtonGameOver(chosen_item_gameOver);
-
-					if (new_button != NULL && !hand_closed) {
-						//Run function click
-						new_button->ForceClick(GLFW_MOUSE_BUTTON_LEFT);
-						hand_closed = true;
-					}
-				}
-			}
-			glfwSwapBuffers(window);
-			glfwPollEvents();
-		}
-
-		gui_shader_gameOver->CleanUp();
-		render_engine::loader::CleanUp();
-		return return_value;
-	}
-
-	/**
-	 * renders the models in the start-up scene
-	 */
-	void scene::Game_Over_Scene::render()
-	{
-		render_engine::renderer::Prepare();
-
-		// Render GUI items
-		render_engine::renderer::Render(guis_gameOver, *gui_shader_gameOver);
-	}
-
-	/**
-	 * updates the variables for the start-up scene
-	 */
-	void scene::Game_Over_Scene::update(GLFWwindow* window)
-	{
-		for (gui::GuiTexture* button : guis_gameOver) {
-			gui::Button* new_button = ConvertGuiTextureToButtonGameOver(button);
-			if (new_button != NULL)
-				new_button->Update(window);
-		}
-		bool hand_present;
-		objDetect_gameOver.DetectHand(objDetect_gameOver.ReadCamera(), hand_present);
-	}
-
-	/**
-	 * manages the key input in the start-up scene
-	 */
-	void scene::Game_Over_Scene::onKey(GLFWwindow* window, int key, int scancode, int action, int mods)
-	{
-		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_gameOver = !hand_mode_gameOver;
-		}
-	}
-}

src/scenes/game_Over_Scene.h

@@ -1,26 +0,0 @@
-#pragma once
-#include "scene.h"
-#include "../gui/gui_element.h"
-
-namespace scene
-{
-	extern GLFWwindow* window;
-
-	class Game_Over_Scene : public scene::Scene
-	{
-	private:
-		scene::Scenes return_value = scene::Scenes::GAMEOVER;
-
-	public:
-		Game_Over_Scene();
-
-		Scenes start(GLFWwindow* window) override;
-
-		void render() override;
-
-		void update(GLFWwindow* window) override;
-
-		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
-
-	};
-}

src/scenes/in_Game_Scene.cpp

@@ -1,27 +1,4 @@
-#include <iostream>
-#include <memory>
-#include <GL/glew.h>
-#include <GLFW/glfw3.h>
 #include "in_Game_Scene.h"
-#include "startup_Scene.h"
-#include "../entities/main_character.h"
-#include "../collision/collision_handler.h"
-#include "../gui/gui_interactable.h"
-#include "../models/model.h"
-#include "../renderEngine/loader.h"
-#include "../renderEngine/obj_loader.h"
-#include "../renderEngine/renderer.h"
-#include "../shaders/entity_shader.h"
-#include "../toolbox/toolbox.h"
-#include "../entities/house_generator.h"
-#include <deque>
-#include <functional>
-#include <memory>
-#include <queue>
-#include <opencv2/core/base.hpp>
-#include "../computervision/HandDetectRegion.h"
-#include "../computervision/ObjectDetection.h"
-#include <string>
 
 #define MAX_MODEL_DEQUE_SIZE 6 // max amount of models to load at the same time
 #define UPCOMING_MODEL_AMOUNT 4 // how much models should be loaded in front of us
@@ -31,7 +8,6 @@ namespace scene
 {
 	std::shared_ptr<entities::MainCharacter>main_character;
 	std::vector<std::shared_ptr<entities::CollisionEntity>> collision_entities;
-
 	entities::HouseGenerator* house_generator;
 	std::deque<std::shared_ptr<entities::Entity>> house_models;
 
@@ -45,6 +21,8 @@ namespace scene
 	int furniture_count_old;
 	int score;
 
+	float delta_time = 0;
+
 	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);
 
@@ -74,11 +52,8 @@ namespace scene
 			score_pointer = std::make_unique<gui::GuiTexture>(render_engine::loader::LoadTexture(texture_path), glm::vec2(-0.9f, 0.8f), glm::vec2(0.07, 0.15));
 
 			score_textures.push_back(score_pointer);
-
-			std::cout << "Add to score_pointer: " << texture_path << std::endl;
 		}
 
-		std::cout << "Size textures: " << score_textures.size() << std::endl;
 
 	}
 
@@ -105,44 +80,46 @@ namespace scene
 	}
 
 	
-	/**
-	 * @brief loads a new chunk in front of the camera, and deletes the chunk behind the camera.
-	 *
-	 * @param model_pos the amount of models the camera has passed already. This is the rounded result of (z position of camera) / (size of model)
-	 *
-	 */
-	void load_chunk(int model_pos)
+	void In_Game_Scene::SetupHandDetection()
 	{
-		static unsigned int furniture_count = 0;
-
 		// 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.SetMainSkinDetecRegion(true);
+		reg_right.SetMainSkinDetecRegion(false);
+		reg_right.SetMainSkinDetecRegion(false);
+		std::function<void()> callback = [this]() {OnSkinCalibrationCallback(); };
+		reg_left.SetSkinTimerCallback(callback);
+
 		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);
+	}
+
+	
+	void In_Game_Scene::LoadChunk(int model_pos)
+	{
+		static unsigned int furniture_count = 0;
 		std::cout << "loading model chunk" << std::endl;
 		if (house_models.size() >= MAX_MODEL_DEQUE_SIZE * furniture_count)
 		{
 			for (int i = 0; i < furniture_count; i++)
 			{
 				house_models.pop_front();
-				collision_entities.pop_back();
 			}
 		}
 		int z_offset = model_pos * (house_generator->GetHouseDepth()); // how much "in the distance" we should load the model
 
-		std::deque<std::shared_ptr<entities::CollisionEntity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
+		std::deque<std::shared_ptr<entities::Entity>> furniture = house_generator->GenerateHouse(glm::vec3(0, -75, -50 - z_offset), 90);
 		furniture_count = furniture.size();
 
 		house_models.insert(house_models.end(), furniture.begin(), furniture.end());
-		collision_entities.insert(collision_entities.end(), furniture.begin(), furniture.end());
 		std::cout << "funriture_count in load chunk (house included): " << furniture_count << std::endl;
 		furniture_count_old = furniture_count - 1;
-
 	}
 
 	/**
@@ -154,16 +131,20 @@ namespace scene
 		texture.shine_damper = 10;
 		texture.reflectivity = 0;
 
+
 		raw_model_char = render_engine::LoadObjModel("res/beeTwo.obj");
 		models::TexturedModel model_char = { raw_model_char, texture };
 		collision::Box char_box = create_bounding_box(raw_model_char.model_size, glm::vec3(0, 0, 0), 1);
 		main_character = std::make_shared<entities::MainCharacter>(model_char, glm::vec3(0, -50, -100), glm::vec3(0, 90, 0), 5, char_box);
 		collision_entities.push_back(main_character);
 		house_generator = new entities::HouseGenerator();
+
+		SetupHandDetection();
+
 		// load the first few house models
 		for (int i = 0; i <= UPCOMING_MODEL_AMOUNT; i++)
 		{
-			load_chunk(i);
+			LoadChunk(i);
 		}
 
 		lights.push_back(entities::Light(glm::vec3(0, 1000, 7000), glm::vec3(5, 5, 5))); // sun
@@ -229,6 +210,7 @@ namespace scene
 				break;
 			}
 
+
 			glfwSwapBuffers(window);
 			glfwPollEvents();
 		}
@@ -270,12 +252,9 @@ namespace scene
 	//updates certain variables 
 	void scene::In_Game_Scene::update(GLFWwindow* window)
 	{
+		UpdateDeltaTime();
 		//camera.Move(window);
 		main_character->Move(window);
-		if (!main_character.get()->GetOnCollide())
-		{
-			//return_value = scene::Scenes::GAMEOVER;
-		}
 
 		//std::cout << "x get: " << movement.x << "\ny get: " << movement.y << "\nz get: " << movement.z << "\n";
 		camera->Follow(main_character->GetPosition());
@@ -287,18 +266,19 @@ namespace scene
 		// if we have passed a model, load a new one and delete the one behind us
 		if (last_model_pos != model_pos)
 		{
-			load_chunk(model_pos + UPCOMING_MODEL_AMOUNT);
+			LoadChunk(model_pos + UPCOMING_MODEL_AMOUNT);
 			score += furniture_count_old;
 			std::cout << "Score: " << score << std::endl;
 			std::cout << "Furniture_count_old in model (house excluded): " << furniture_count_old << std::endl;
+
 		}
 		// remember the position at which the new model was added
 		last_model_pos = model_pos;
 
-		std::cout << "amount of collision entities: " << collision_entities.size() << std::endl;
 		collision::CheckCollisions(collision_entities);
-		
 		update_hand_detection();
+
+
 	}
 
 	//manages the key input in the game scene
@@ -317,24 +297,14 @@ namespace scene
 		{
 			game_state = scene::Game_State::RUNNING;
 		}
-
-		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()
 	{
+		reg_left.UpdateTime(delta_time);
+		reg_right.UpdateTime(delta_time);
+		reg_up.UpdateTime(delta_time);
+
 		cv::Mat camera_frame;
 		static_camera::getCap().read(camera_frame);
 		reg_left.DetectHand(camera_frame);
@@ -344,6 +314,14 @@ namespace scene
 		cv::imshow("camera", camera_frame);
 	}
 
+	void scene::In_Game_Scene::OnSkinCalibrationCallback()
+	{
+		std::cout << "on skin calibration callback" << std::endl;
+		std::vector<int> tresholds = reg_left.CalculateSkinTresholds();
+		reg_right.setSkinTresholds(tresholds);
+		reg_up.setSkinTresholds(tresholds);
+	}
+
 	//renders the models for the pause menu
 	void In_Game_Scene::render_pause_menu()
 	{
@@ -357,11 +335,20 @@ namespace scene
 
 		toolbox::GetDigitsFromNumber(score, digits);
 
-		for (int i = digits.size()-1; i >= 0; i--)
+		for (int i = digits.size() - 1; i >= 0; i--)
 		{
-			score_textures[digits[i]].get()->position.x = 0.15 * i -0.9;
+			score_textures[digits[i]].get()->position.x = 0.15 * i - 0.9; // place the number at the top left. the numbers are just fine tuned to get the position just right
 			render_engine::renderer::Render(score_textures[digits[i]], *gui_shader);
 
 		}
 	}
+
+	void In_Game_Scene::UpdateDeltaTime()
+	{
+		double current_time = glfwGetTime();
+		static double last_frame_time = current_time;
+		delta_time = current_time - last_frame_time;
+		last_frame_time = current_time;
+
+	}
 }

src/scenes/in_Game_Scene.h

@@ -3,6 +3,18 @@
 #include <ostream>
 #include <vector>
 #include <memory>
+#include <string>
+#include <opencv2/core/base.hpp>
+#include <opencv2/imgcodecs.hpp>
+#include <opencv2/imgproc.hpp>
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+#include <deque>
+#include <functional>
+#include <queue>
+#include <opencv2/core/base.hpp>
+
+#include "startup_Scene.h"
 #include "scene.h"
 #include "../gui/gui_interactable.h"
 #include "../models/model.h"
@@ -11,9 +23,12 @@
 #include "../renderEngine/renderer.h"
 #include "../shaders/entity_shader.h"
 #include "../toolbox/toolbox.h"
-#include <opencv2/core/base.hpp>
-#include <opencv2/imgcodecs.hpp>
-#include <opencv2/imgproc.hpp>
+#include "../entities/main_character.h"
+#include "../collision/collision_handler.h"
+#include "../entities/house_generator.h"
+#include "../computervision/hand_detect_region.h"
+#include "../computervision/object_detection.h"
+
 
 
 namespace scene
@@ -56,17 +71,51 @@ namespace scene
 		std::vector<gui::GuiTexture*> guis;
 		//pause_guis is a list of components that will be rendered when the game is paused.
 		std::vector<gui::GuiTexture*> pause_guis;
-
+		// list of gui texture that holds the textures for the score
 		std::vector<std::shared_ptr<gui::GuiTexture>> score_guis;
 
+		void UpdateDeltaTime();
+
 		/**
 		 * @brief renders the objects/gui models
 		 * @param 
 		 * @return void
 		 */
 		void render_pause_menu();
+
+		/**
+		 * @brief updates the hand detection with the deltatime and checks the hand detection for each region. als updates the camera display
+		 *
+		 */
 		void update_hand_detection();
 
+		/**
+		 * @brief sets up the hand detection regions and sets the callbacks for the skin calibration.
+		 *
+		 */
+		void SetupHandDetection();
+
+		/**
+		 * @brief callback that gets called when the left skin detect region timout has been reached. sets the other regions with the skin data from the first region
+		 *
+		 */
+		void OnSkinCalibrationCallback();
+
+		/**
+		 * @brief draws the score on the screen with the digit resources.
+		 * 
+		 * @param score the score to display.
+		 */
+		void DrawScore(int score);
+
+		/**
+		 * @brief loads a new chunk in front of the camera, and deletes the chunk behind the camera.
+		 *
+		 * @param model_pos the amount of models the camera has passed already. This is the rounded result of (z position of camera) / (size of model)
+		 *
+		 */
+		void LoadChunk(int model_pos);
+	
 	public:
 		In_Game_Scene();
 		~In_Game_Scene();
@@ -103,11 +152,7 @@ namespace scene
 		 */
 		void onKey(GLFWwindow* window, int key, int scancode, int action, int mods) override;
 	
-		/**
-		* @brief: This method renders the score points onto the game window
-		* @param score: Score to show
-		*/
-		void DrawScore(int score);
+		
 
 	};
 }

src/scenes/startup_Scene.cpp

@@ -14,8 +14,8 @@
 #include "../gui/gui_interactable.h"
 #include "../toolbox/toolbox.h"
 #include "../computervision/MenuTest.h"
-#include "../computervision/ObjectDetection.h"
-#include "../computervision/HandDetectRegion.h"
+#include "../computervision/object_detection.h"
+#include "../computervision/hand_detect_region.h"
 
 
 

src/toolbox/Timer.h

@@ -42,5 +42,7 @@ namespace toolbox
 		 * @return: True if the timer has finished 
 		 */
 		bool HasFinished() const { return has_finished; }
+
+		void Reset() { current_time = 0; }
 	};
 }

wk2_fps.vcxproj

@@ -23,16 +23,15 @@
     <ClCompile Include="src\entities\main_character.cpp" />
     <ClCompile Include="src\entities\house_generator.cpp" />
     <ClCompile Include="src\computervision\calibration\HandCalibrator.cpp" />
-    <ClCompile Include="src\computervision\HandDetectRegion.cpp" />
-    <ClCompile Include="src\scenes\game_Over_Scene.cpp" />
+    <ClCompile Include="src\computervision\hand_detect_region.cpp" />
     <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
     <ClCompile Include="src\computervision\MenuTest.cpp" />
     <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
-    <ClCompile Include="src\computervision\ObjectDetection.cpp" />
+    <ClCompile Include="src\computervision\object_detection.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" />
+    <ClCompile Include="src\computervision\skin_detector.cpp" />
+    <ClCompile Include="src\computervision\finger_count.cpp" />
+    <ClCompile Include="src\computervision\background_remover.cpp" />
     <ClCompile Include="src\entities\camera.cpp" />
     <ClCompile Include="src\entities\collision_entity.cpp" />
     <ClCompile Include="src\entities\entity.cpp" />
@@ -55,18 +54,17 @@
     <ClInclude Include="src\entities\house_generator.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\game_Over_Scene.h" />
+    <ClInclude Include="src\computervision\hand_detect_region.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\async\StaticCameraInstance.h" />
-    <ClInclude Include="src\computervision\FingerCount.h" />
-    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\finger_count.h" />
+    <ClInclude Include="src\computervision\background_remover.h" />
     <ClInclude Include="src\computervision\MenuTest.h" />
     <ClInclude Include="src\computervision\OpenPoseVideo.h" />
-    <ClInclude Include="src\computervision\SkinDetector.h" />
-    <ClInclude Include="src\computervision\ObjectDetection.h" />
+    <ClInclude Include="src\computervision\skin_detector.h" />
+    <ClInclude Include="src\computervision\object_detection.h" />
     <ClInclude Include="src\entities\camera.h" />
     <ClInclude Include="src\entities\collision_entity.h" />
     <ClInclude Include="src\entities\entity.h" />

wk2_fps.vcxproj.filters

@@ -4,11 +4,11 @@
     <ClCompile Include="src\collision\collision_handler.cpp" />
     <ClCompile Include="src\scenes\in_Game_Scene.cpp" />
     <ClCompile Include="src\computervision\async\async_arm_detection.cpp" />
-    <ClCompile Include="src\computervision\ObjectDetection.cpp" />
+    <ClCompile Include="src\computervision\object_detection.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" />
+    <ClCompile Include="src\computervision\skin_detector.cpp" />
+    <ClCompile Include="src\computervision\finger_count.cpp" />
+    <ClCompile Include="src\computervision\background_remover.cpp" />
     <ClCompile Include="src\entities\camera.cpp" />
     <ClCompile Include="src\entities\collision_entity.cpp" />
     <ClCompile Include="src\entities\entity.cpp" />
@@ -23,12 +23,11 @@
     <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" />
+    <ClCompile Include="src\computervision\hand_detect_region.cpp" />
     <ClCompile Include="src\entities\main_character.cpp" />
     <ClCompile Include="src\entities\house_generator.cpp" />
     <ClCompile Include="src\computervision\MenuTest.cpp" />
     <ClCompile Include="src\scenes\scene.cpp" />
-    <ClCompile Include="src\scenes\game_Over_Scene.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="src\entities\Camera.cpp">
@@ -119,7 +118,7 @@
     <ClInclude Include="src\toolbox\toolbox.h" />
     <ClInclude Include="src\scenes\startup_Scene.h" />
     <ClInclude Include="src\computervision\calibration\HandCalibrator.h" />
-    <ClInclude Include="src\computervision\HandDetectRegion.h" />
+    <ClInclude Include="src\computervision\hand_detect_region.h" />
     <ClInclude Include="src\computervision\calibration\StaticSkinTreshold.h" />
     <ClInclude Include="src\collision\collision.h" />
     <ClInclude Include="src\collision\collision_handler.h" />
@@ -127,11 +126,11 @@
     <ClInclude Include="src\entities\house_generator.h" />
     <ClInclude Include="src\scenes\in_Game_Scene.h" />
     <ClInclude Include="src\scenes\scene.h" />
-    <ClInclude Include="src\computervision\FingerCount.h" />
-    <ClInclude Include="src\computervision\BackgroundRemover.h" />
+    <ClInclude Include="src\computervision\finger_count.h" />
+    <ClInclude Include="src\computervision\background_remover.h" />
     <ClInclude Include="src\computervision\MenuTest.h" />
-    <ClInclude Include="src\computervision\SkinDetector.h" />
-    <ClInclude Include="src\computervision\ObjectDetection.h" />
+    <ClInclude Include="src\computervision\skin_detector.h" />
+    <ClInclude Include="src\computervision\object_detection.h" />
     <ClInclude Include="src\entities\camera.h" />
     <ClInclude Include="src\entities\collision_entity.h" />
     <ClInclude Include="src\entities\entity.h" />
@@ -149,7 +148,6 @@
     <ClInclude Include="src\toolbox\Timer.h" />
     <ClInclude Include="src\toolbox\toolbox.h" />
     <ClInclude Include="src\scenes\startup_Scene.h" />
-    <ClInclude Include="src\scenes\game_Over_Scene.h" />
   </ItemGroup>
   <ItemGroup>
     <Xml Include="res\haarcascade_frontalface_alt.xml" />