added yolo image object detection to /image

docs/Infrastructure/system-services.md

@@ -0,0 +1,51 @@
+# Systemd Services
+
+# What is a service
+A service is a program or script that runs in the background and is managed by the system. Services are started at boot time and run until the system is shut down. Services can be started, stopped, and restarted by the system administrator.
+
+# How to manage services on systemD
+
+## Starting a service
+To start a service, use the `systemctl start` command followed by the service name. For example, to start the `apache2` service, use the following command:
+
+```bash
+sudo systemctl start apache2
+```
+
+## Stopping a service
+To stop a service, use the `systemctl stop` command followed by the service name. For example, to stop the `apache2` service, use the following command:
+
+```bash
+sudo systemctl stop apache2
+```
+
+## Restarting a service
+To restart a service, use the `systemctl restart` command followed by the service name. For example, to restart the `apache2` service, use the following command:
+
+```bash
+sudo systemctl restart apache2
+```
+
+## Enabling a service
+To enable a service to start at boot time, use the `systemctl enable` command followed by the service name. For example, to enable the `apache2` service, use the following command:
+
+```bash
+sudo systemctl enable apache2
+```
+
+## Creating a new service
+To create a new service, you need to create a new service file in the `/etc/systemd/system/` directory. The service file should have a `.service` extension and contain the following sections:
+
+### Example service file:
+
+```bash
+[Unit]
+Description=FlaskApp #description of the service
+After=network.target #start the service after the network is up
+
+[Service]
+User=ishak #start the service as a specific user
+WorkingDirectory=/home/ishak/rooziinuubii79/src/Python/flask/web/ #working directory of the service
+ExecStart=/usr/bin/gunicorn -w 3 -b 127.0.0.1:5000 app:app #command to start the service
+```
+

src/C++/Driver/src/MQTT/MqttClient.cpp

@@ -37,7 +37,6 @@ void MqttClient::subscribe(const std::string& topic, int qos) {
 
 void MqttClient::publishMessage(const std::string& topic, const std::string& payload) {
     try {
-        std::cout << "Publishing message: " << payload << std::endl;
         client_.publish(topic, payload)->wait();
     } catch (const mqtt::exception& exc) {
         std::cerr << "Error: " << exc.what() << std::endl;

src/C++/Driver/src/main.cpp

@@ -312,6 +312,6 @@ void CapnSend() {
         client.publishMessage("kobuki/cam", string(enc_msg, enc_msg + buf.size()));
         cout << "Sent image" << endl;
 
-        std::this_thread::sleep_for(std::chrono::milliseconds(300)); // Send image every 1000ms
+        std::this_thread::sleep_for(std::chrono::milliseconds(200)); // Send image every 200ms
     }
 }

src/Python/YOLO/app.py

@@ -0,0 +1,41 @@
+from ultralytics import YOLO
+import cv2
+import numpy as np
+import requests
+import time
+
+model = YOLO("yolo11n.pt") 
+
+#try to fetch the image from the given url
+def fetch_image(url):
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+        image_array = np.frombuffer(response.content, np.uint8)
+        image = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+        return image
+    except requests.RequestException as e:
+        print(f"Error: Could not fetch image - {e}")
+        return None
+
+# URL of the photostream
+url = "http://145.92.224.21/image"
+
+while True:
+    frame = fetch_image(url)
+    if frame is None:
+        print("Error: Could not fetch image, retrying...")
+        time.sleep(1)  # Wait for 1 second before retrying
+        continue
+
+    # Predict on the frame
+    results = model(frame)
+
+    # Display the results
+    results[0].show()
+
+    # Exit if 'q' is pressed
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+
+cv2.destroyAllWindows()

src/Python/flask/web/app.py

@@ -1,20 +1,44 @@
 from flask import Flask, Response, request, render_template, jsonify
 import paho.mqtt.client as mqtt
+from ultralytics import YOLO
+import cv2
+import numpy as np
 
 app = Flask(__name__)
 
+# Load a model
+model = YOLO("yolo11n.pt")  # pretrained YOLO11n model
+
+kobuki_message = ""
+latest_image = None
+yolo_results = []
+
 def on_message(client, userdata, message):
-    global kobuki_message, latest_image
+    global kobuki_message, latest_image, yolo_results
     if message.topic == "kobuki/data":
         kobuki_message = str(message.payload.decode("utf-8"))
     elif message.topic == "kobuki/cam":
-        latest_image = message.payload
-
+        latest_image = np.frombuffer(message.payload, np.uint8)
+        latest_image = cv2.imdecode(latest_image, cv2.IMREAD_COLOR)
+        # Process the image with YOLO
+        results = model(latest_image)
+        yolo_results = []
+        for result in results:
+            for box in result.boxes:
+                yolo_results.append({
+                    "class": box.cls,
+                    "confidence": box.conf,
+                    "bbox": box.xyxy.tolist()
+                })
+                # Draw bounding box on the image
+                x1, y1, x2, y2 = map(int, box.xyxy)
+                cv2.rectangle(latest_image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                cv2.putText(latest_image, f"{box.cls} {box.conf:.2f}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
 
 # Create an MQTT client instance
 mqtt_client = mqtt.Client()
 mqtt_client.username_pw_set("server", "serverwachtwoordofzo")
-mqtt_client.connect("localhost", 1884, 60)
+mqtt_client.connect("localhost", 1883, 60)
 mqtt_client.loop_start()
 mqtt_client.subscribe("kobuki/data")
 mqtt_client.subscribe("kobuki/cam")
@@ -53,18 +77,15 @@ def data():
 def image():
     global latest_image
     if latest_image is not None:
-        return Response(latest_image, mimetype='image/jpeg')
+        _, buffer = cv2.imencode('.jpg', latest_image)
+        return Response(buffer.tobytes(), mimetype='image/jpeg')
     else:
         return "No image available", 404
 
-
-@app.route('/phpmyadmin/<path:path>')
-def phpmyadmin_passthrough(path):
-    # Laat Apache deze route direct afhandelen
-    return "", 404
-
-
-
+@app.route('/yolo_results', methods=['GET'])
+def yolo_results_endpoint():
+    global yolo_results
+    return jsonify(yolo_results)
 
 if __name__ == '__main__':
-    app.run(debug=True, port=5000)
+    app.run(debug=True, port=5000)

src/Python/flask/web/static/script.js

@@ -14,7 +14,7 @@ document.addEventListener("DOMContentLoaded", function() {
         body: JSON.stringify({ direction: direction })
       })
       .then(response => response.json())
-      .then(data => {script
+      .then(data => {
         console.log("Success:", data);
       })
       .catch(error => {
@@ -25,12 +25,13 @@ document.addEventListener("DOMContentLoaded", function() {
 
   // Fetch data from the server
   async function fetchData() {
-    try{
-    const response = await fetch("/data");
-    const data = await response.json();
-    return data;
-  } catch (error) {
-    console.error("Error:", error);
+    try {
+      const response = await fetch("/data");
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      console.error("Error:", error);
+    }
   }
 
   // Parse the data and show it on the website
@@ -52,9 +53,9 @@ document.addEventListener("DOMContentLoaded", function() {
     img.src = "/image?" + new Date().getTime(); // Add timestamp to avoid caching
   }
 
-  // Fetch and display sensor data every 5 seconds
+  // Fetch and display sensor data every 1 second
   setInterval(parseData, 1000);
 
-  // Update the image every 5 seconds
-  setInterval(updateImage, 200);
+  // Update the image every 200 milliseconds
+  setInterval(updateImage, 100);
 });

src/config/rpi/kobukiDriver.service

@@ -0,0 +1,9 @@
+[Unit]
+Description=kobukiDriver
+After=network.target
+
+[Service]
+User=user1
+WorkingDirectory=/home/user1/rooziinuubii79/src/C++/Driver/
+ExecStart=/home/user1/rooziinuubii79/src/C++/Driver/kobuki_control
+Restart=always