added mutex in python

src/Python/flask/web/app.py

@@ -3,6 +3,7 @@ import paho.mqtt.client as mqtt
 from ultralytics import YOLO
 import cv2
 import numpy as np
+import threading
 
 app = Flask(__name__)
 
@@ -14,6 +15,9 @@ latest_image = None
 processed_image = None
 yolo_results = []
 
+# Lock for thread-safe access to shared variables
+lock = threading.Lock()
+
 # List of class names (example for COCO dataset)
 yolo_classes = list(model.names.values())
 
@@ -22,25 +26,26 @@ def on_message(client, userdata, message):
     if message.topic == "kobuki/data":
         kobuki_message = str(message.payload.decode("utf-8"))
     elif message.topic == "kobuki/cam":
-        latest_image = np.frombuffer(message.payload, np.uint8)
+        with lock: # Lock the shared variables between threads so they can't be accessed at the same time and you cant have half processed images
-        latest_image = cv2.imdecode(latest_image, cv2.IMREAD_COLOR)
+            latest_image = np.frombuffer(message.payload, np.uint8)
-        processed_image = latest_image.copy()  # Create a copy for processing
+            latest_image = cv2.imdecode(latest_image, cv2.IMREAD_COLOR)
-        # Process the image with YOLO
+            # Process the image with YOLO
-        results = model(latest_image)
+            results = model(latest_image)
-        yolo_results = []
+            yolo_results = []
-        for result in results:
+            processed_image = latest_image.copy()  # Create a copy for processing
-            for box in result.boxes:
+            for result in results:
-                class_id = int(box.cls.item())
+                for box in result.boxes:
-                class_name = yolo_classes[class_id]
+                    class_id = int(box.cls.item())
-                yolo_results.append({
+                    class_name = yolo_classes[class_id]
-                    "class": class_name,
+                    yolo_results.append({
-                    "confidence": box.conf.item(),
+                        "class": class_name,
-                    "bbox": box.xyxy.tolist()
+                        "confidence": box.conf.item(),
-                })
+                        "bbox": box.xyxy.tolist()
-                # Draw bounding box on the processed image
+                    })
-                x1, y1, x2, y2 = map(int, box.xyxy[0])
+                    # Draw bounding box on the processed image
-                cv2.rectangle(processed_image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                    x1, y1, x2, y2 = map(int, box.xyxy[0])
-                cv2.putText(processed_image, f"{class_name} {box.conf.item():.2f}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+                    cv2.rectangle(processed_image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+                    cv2.putText(processed_image, f"{class_name} {box.conf.item():.2f}", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
 
 # Create an MQTT client instance
 mqtt_client = mqtt.Client()
@@ -50,20 +55,21 @@ mqtt_client.loop_start()
 mqtt_client.subscribe("kobuki/data")
 mqtt_client.subscribe("kobuki/cam")
 
-mqtt_client.on_message = on_message # this line needs to be under the function definition otherwise it cant find which function it needs to use
+mqtt_client.on_message = on_message  # this line needs to be under the function definition otherwise it can't find which function it needs to use
 
 @app.route('/')
 def index():
     return render_template('index.html')
 
 
-@app.route('/control', methods=["GET","POST"])
+@app.route('/control', methods=["GET", "POST"])
 def control():
     if request.authorization and request.authorization.username == 'ishak' and request.authorization.password == 'kobuki':
         return render_template('control.html')
     else:
         return ('Unauthorized', 401, {'WWW-Authenticate': 'Basic realm="Login Required"'})
 
+
 @app.route('/move', methods=['POST'])
 def move():
     data = request.get_json()
@@ -80,19 +86,24 @@ def move():
 def data():
     return kobuki_message
 
+
 @app.route('/image')
 def image():
     global processed_image
-    if processed_image is not None:
+    with lock: # Lock the shared variables between threads so they can't be accessed at the same time and you cant have half processed images
-        _, buffer = cv2.imencode('.jpg', processed_image)
+        if processed_image is not None:
-        return Response(buffer.tobytes(), mimetype='image/jpeg')
+            _, buffer = cv2.imencode('.jpg', processed_image) 
-    else:
+            return Response(buffer.tobytes(), mimetype='image/jpeg')
-        return "No image available", 404
+        else:
+            return "No image available", 404
+
 
 @app.route('/yolo_results', methods=['GET'])
 def yolo_results_endpoint():
     global yolo_results
-    return jsonify(yolo_results)
+    with lock:
+        return jsonify(yolo_results)
+
 
 if __name__ == '__main__':
     app.run(debug=True, port=5000)