done

- Corrected inconsistent indentation to avoid runtime .
- Ensured that all indentation levels match Python's expected format.

dayglo_detector/Dockerfile

@@ -7,10 +7,10 @@ RUN apt-get update && apt-get install -y \
  && rm -rf /var/lib/apt/lists/*
 
 # Install OpenCV
-RUN pip install --no-cache-dir paho-mqtt opencv-python-headless numpy requests
+RUN pip install --no-cache-dir gmqtt opencv-python-headless numpy requests
 
 # Copy the dayglo detector script
-COPY dayglo_detector.py /app/dayglo_detector.py
+COPY dayglo_detector.py test_mqtt.py /app/
 
 WORKDIR /app
 

dayglo_detector/dayglo_detector.py

@@ -1,158 +1,64 @@
 import os
-import paho.mqtt.client as mqtt
-import json
-import requests
-import cv2
-import numpy as np
 import time
-import threading
-
-# Configuration from environment variables
-MQTT_BROKER = os.environ.get('MQTT_BROKER', 'frigate')
-MQTT_PORT = int(os.environ.get('MQTT_PORT', '1883'))
-MQTT_USERNAME = os.environ.get('MQTT_USERNAME')
-MQTT_PASSWORD = os.environ.get('MQTT_PASSWORD')
-MQTT_TOPIC_SUBSCRIBE = 'frigate/events'
-MQTT_TOPIC_PUBLISH = 'homeassistant/sensor/dayglo_rating/state'
-FRIGATE_URL = os.environ.get('FRIGATE_URL', 'http://frigate:5000')
-INTERESTED_ZONES = ['Door_Front']
-
-# Debug mode flag
-DEBUG_MODE = True
-
-def debug_print(message):
-    """ Helper function to print debug messages if debug mode is enabled """
-    if DEBUG_MODE:
-        print(f"[DEBUG] {message}")
-
-def calculate_dayglo_rating(image):
-    debug_print("Calculating dayglo rating...")
-    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
-
-    # Define HSV range for "dayglo" colors (adjust as needed)
-    lower_color = np.array([20, 100, 100])
-    upper_color = np.array([40, 255, 255])
-
-    # Create a mask for the colors
-    mask = cv2.inRange(hsv_image, lower_color, upper_color)
-
-    # Calculate the percentage of "dayglo" pixels
-    dayglo_pixels = cv2.countNonZero(mask)
-    total_pixels = image.shape[0] * image.shape[1]
-    dayglo_rating = (dayglo_pixels / total_pixels) * 100
-
-    debug_print(f"Dayglo Rating calculated: {dayglo_rating:.2f}%")
-    return dayglo_rating
-
-def on_connect(client, userdata, flags, rc):
-    debug_print(f"Connected to MQTT broker with result code {rc}")
-    client.subscribe(MQTT_TOPIC_SUBSCRIBE)
-
-def on_message(client, userdata, msg):
-    debug_print("MQTT message received")
-    payload = json.loads(msg.payload)
-    event_type = payload.get('type')
-    after = payload.get('after', {})
-    label = after.get('label')
-
-    if event_type == 'new' and label == 'person':
-        zones = after.get('entered_zones', [])
-        if any(zone in INTERESTED_ZONES for zone in zones):
-            debug_print(f"Person detected in zones: {zones}")
-            threading.Thread(target=process_event, args=(after,)).start()
-
-def process_event(event_data):
-    event_id = event_data.get('id')
-    camera = event_data.get('camera')
-    debug_print(f"Processing event {event_id} from camera {camera}")
-
-    # Get the snapshot URL for the event
-    snapshot_url = f"{FRIGATE_URL}/api/events/{event_id}/snapshot.jpg"
-
-    # Retrieve the snapshot
-    try:
-        response = requests.get(snapshot_url)
-        if response.status_code == 200:
-            debug_print(f"Snapshot retrieved successfully from {snapshot_url}")
-            np_arr = np.frombuffer(response.content, np.uint8)
-            image = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
-            if image is not None:
-                dayglo_rating = calculate_dayglo_rating(image)
-                debug_print(f"Publishing dayglo rating: {dayglo_rating:.2f}%")
-                client.publish(MQTT_TOPIC_PUBLISH, f"{dayglo_rating:.2f}")
-            else:
-                debug_print("Failed to decode the snapshot image")
-        else:
-            debug_print(f"Failed to retrieve snapshot. HTTP Status code: {response.status_code}")
-    except Exception as e:
-        debug_print(f"Error retrieving snapshot: {e}")
-
-def assess_latest_image():
-    """ Assess the most recent image when the script first starts """
-    debug_print("Assessing the most recent image on startup...")
-
-    # Retrieve the most recent event from Frigate
-    events_url = f"{FRIGATE_URL}/api/events?limit=1&has_snapshot=1"
-    try:
-        response = requests.get(events_url)
-        if response.status_code == 200:
-            events = response.json()
-            if events:
-                event_data = events[0]
-                debug_print(f"Most recent event ID: {event_data.get('id')}")
-                process_event(event_data)
-            else:
-                debug_print("No recent events found with snapshots")
-        else:
-            debug_print(f"Failed to retrieve events. HTTP Status code: {response.status_code}")
-    except Exception as e:
-        debug_print(f"Error retrieving events: {e}")
-
-# MQTT setup
-#client = mqtt.Client()
-client = mqtt.Client(protocol=mqtt.MQTTv5)
-#client = mqtt.Client(protocol=mqtt.MQTTv311)
-
-if MQTT_USERNAME and MQTT_PASSWORD:
-    client.username_pw_set(MQTT_USERNAME, MQTT_PASSWORD)
-
-client.on_connect = on_connect
-client.on_message = on_message
-
-# Start MQTT connection
-debug_print(f"Connecting to MQTT broker at {MQTT_BROKER}:{MQTT_PORT}...")
-client.connect(MQTT_BROKER, MQTT_PORT, 60)
-
-# Assess the latest image when the script starts
-assess_latest_image()
-
-# Start the MQTT loop
-client.loop_forever()
-
-import os
-import paho.mqtt.client as mqtt
 import numpy as np
 import cv2
 import base64
 import json
+import tempfile
+import sys
+import asyncio
+from gmqtt import Client as MQTTClient
 
 # Configuration
 MQTT_BROKER = os.environ.get('MQTT_BROKER', '10.59.221.172')
 MQTT_PORT = int(os.environ.get('MQTT_PORT', '1883'))
+MQTT_USERNAME = os.getenv('MQTT_USERNAME', 'your_username')
+MQTT_PASSWORD = os.getenv('MQTT_PASSWORD', 'your_password')
 MQTT_SNAPSHOT_TOPIC = "/frigate/patiocam/person/snapshot"
 MQTT_TOPIC_PUBLISH = "homeassistant/sensor/dayglo_rating/state"
-DAYGLO_THRESHOLD_TOPIC = "homeassistant/sensor/dayglo_threshold/state"
 DISCOVERY_PREFIX = "homeassistant"
 
-# Default threshold
+# Default rating
-dayglo_threshold = 50
+last_rating = 0
 
-def on_connect(client, userdata, flags, rc):
+# Default color thresholds for dayglo detection
-    print("Connected with result code", rc)
+# Expanded color thresholds for dayglo detection
-    client.subscribe(MQTT_SNAPSHOT_TOPIC)
+LOWER_COLOR_GREEN = np.array([35, 50, 50])
-    publish_discovery_configurations()
+UPPER_COLOR_GREEN = np.array([100, 255, 255])
+LOWER_COLOR_YELLOW = np.array([15, 80, 80])
+UPPER_COLOR_YELLOW = np.array([40, 255, 255])
 
-def publish_discovery_configurations():
+# Track if the initial snapshot has been processed
+initial_snapshot_processed = False
+connected_once = False
+
+class DaygloDetectorMQTTClient(MQTTClient):
+    async def handle_on_connect(self, client, flags, rc, properties):
+        asyncio.create_task(self.handle_on_connect(client, flags, rc, properties))
+        global connected_once
+        if rc == 0 and not connected_once:
+            print("Connected successfully to MQTT broker")
+            await client.subscribe(MQTT_SNAPSHOT_TOPIC, qos=1)
+            print(f"Subscribed to topic: {MQTT_SNAPSHOT_TOPIC}")
+            connected_once = True
+            await publish_discovery_configurations(client)
+            # Publish initial rating of 0
+            await publish_rating(client, 0)
+        else:
+            print(f"Failed to connect, return code {rc}")
+
+    async def handle_on_message(self, client, topic, payload, qos, properties):
+        asyncio.create_task(self.handle_on_message(client, topic, payload, qos, properties))
+        if topic == MQTT_SNAPSHOT_TOPIC:
+            print("Snapshot received")
+            if len(payload) == 0:
+                print("Received an empty payload, skipping processing.")
+            else:
+                print(f"Payload length: {len(payload)} bytes")
+                print(f"Payload (first 100 bytes): {payload[:100]}...")
+                await process_snapshot(self, payload)
+
+async def publish_discovery_configurations(client):
     rating_config = {
         "name": "Dayglo Rating",
         "state_topic": MQTT_TOPIC_PUBLISH,
@@ -161,50 +67,80 @@ def publish_discovery_configurations():
         "icon": "mdi:brush",
         "unique_id": "mqtt_dayglo_rating"
     }
-    threshold_config = {
+    await client.publish(f"{DISCOVERY_PREFIX}/sensor/dayglo_rating/config", json.dumps(rating_config), retain=True)
-        "name": "Dayglo Threshold",
-        "state_topic": DAYGLO_THRESHOLD_TOPIC,
-        "unit_of_measurement": "%",
-        "value_template": "{{ value_json.threshold }}",
-        "icon": "mdi:tune-vertical",
-        "unique_id": "mqtt_dayglo_threshold"
-    }
 
-    client.publish(f"{DISCOVERY_PREFIX}/sensor/dayglo_rating/config", json.dumps(rating_config), retain=True)
+async def publish_rating(client, rating):
-    client.publish(f"{DISCOVERY_PREFIX}/sensor/dayglo_threshold/config", json.dumps(threshold_config), retain=True)
+    global last_rating
+    last_rating = rating
+    await client.publish(MQTT_TOPIC_PUBLISH, json.dumps({"rating": rating}))
 
-def on_message(client, userdata, msg):
+async def process_snapshot(client, payload):
-    if msg.topic == MQTT_SNAPSHOT_TOPIC:
+    if not payload:
-        print("Snapshot received")
+        print("Empty payload received, skipping processing.")
-        process_snapshot(msg.payload)
+        return
-    elif msg.topic == DAYGLO_THRESHOLD_TOPIC:
-        global dayglo_threshold
-        dayglo_threshold = float(msg.payload.decode('utf-8'))
-        print("Dayglo threshold updated to:", dayglo_threshold)
 
-def process_snapshot(payload):
+    print("Processing snapshot...")
-    image_data = base64.b64decode(payload)
+    try:
-    nparr = np.frombuffer(image_data, np.uint8)
+        image_data = base64.b64decode(payload)
-    image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as temp_image_file:
+            temp_image_file.write(image_data)
+            temp_image_path = temp_image_file.name
 
-    if image is not None:
+        # Attempt to read the saved image with OpenCV
-        rating = calculate_dayglo_rating(image)
+        image = cv2.imread(temp_image_path)
-        print("Dayglo Rating calculated:", rating)
+
-        client.publish(MQTT_TOPIC_PUBLISH, json.dumps({"rating": rating}))
+        if image is not None:
+            rating = calculate_dayglo_rating(image)
+            print("Dayglo Rating calculated:", rating)
+            await publish_rating(client, rating)
+        else:
+            print("Invalid image format or corrupted image received")
+    except Exception as e:
+        print(f"Error processing snapshot: {e}")
 
 def calculate_dayglo_rating(image):
-    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+    print("Calculating dayglo rating...")
-    lower_color = np.array([20, 100, 100])
+    # Crop the image to focus on the center area
-    upper_color = np.array([40, 255, 255])
+    height, width = image.shape[:2]
-    mask = cv2.inRange(hsv_image, lower_color, upper_color)
+    crop_margin = 0.1  # 10% margin
+    cropped_image = image[int(height * crop_margin):int(height * (1 - crop_margin)),
+                          int(width * crop_margin):int(width * (1 - crop_margin))]
+    hsv_image = cv2.cvtColor(cropped_image, cv2.COLOR_BGR2HSV)
+    mask_green = cv2.inRange(hsv_image, LOWER_COLOR_GREEN, UPPER_COLOR_GREEN)
+    mask_yellow = cv2.inRange(hsv_image, LOWER_COLOR_YELLOW, UPPER_COLOR_YELLOW)
+    mask = cv2.addWeighted(mask_green, 1.0, mask_yellow, 1.0, 0)
     dayglo_pixels = cv2.countNonZero(mask)
-    total_pixels = image.shape[0] * image.shape[1]
+    total_pixels = cropped_image.shape[0] * cropped_image.shape[1]
     rating = (dayglo_pixels / total_pixels) * 100
     return rating
 
-client = mqtt.Client()
+async def main():
-client.on_connect = on_connect
+    print("Starting Dayglo Detector...")
-client.on_message = on_message
+    # Handle command line argument for image file
-client.connect(MQTT_BROKER, MQTT_PORT, 60)
+    if len(sys.argv) > 1:
-client.loop_forever()
+        image_file = sys.argv[1]
+        if os.path.exists(image_file):
+            client = DaygloDetectorMQTTClient("dayglo_detector")
+            client.set_auth_credentials(MQTT_USERNAME, MQTT_PASSWORD)
+            await client.connect(MQTT_BROKER, MQTT_PORT, keepalive=60)
+            print(f"Processing image from file: {image_file}")
+            image = cv2.imread(image_file)
+            if image is not None:
+                rating = calculate_dayglo_rating(image)
+                print("Dayglo Rating calculated from file:", rating)
+                await publish_rating(client, rating)
+            else:
+                print("Invalid image file provided.")
+        else:
+            print(f"File not found: {image_file}")
+
+    # Set up MQTT client for normal operation
+    client = DaygloDetectorMQTTClient("dayglo_detector")
+    client.set_auth_credentials(MQTT_USERNAME, MQTT_PASSWORD)
+
+    await client.connect(MQTT_BROKER, MQTT_PORT, keepalive=60)
+    await asyncio.get_event_loop().create_future()
+
+if __name__ == "__main__":
+    asyncio.run(main())
 

dayglo_detector/test_mqtt.py

@@ -0,0 +1,22 @@
+import os
+import paho.mqtt.client as mqtt
+
+# Configuration
+MQTT_BROKER = os.environ.get('MQTT_BROKER', '10.59.221.172')
+MQTT_PORT = int(os.environ.get('MQTT_PORT', '1883'))
+MQTT_USERNAME = os.getenv('MQTT_USERNAME', 'your_username')
+MQTT_PASSWORD = os.getenv('MQTT_PASSWORD', 'your_password')
+
+client = mqtt.Client(protocol=mqtt.MQTTv311)  # Ensure you are using the correct client version
+client.username_pw_set(MQTT_USERNAME, MQTT_PASSWORD)  # Set the username and password
+
+def on_connect(client, userdata, flags, rc):
+    if rc == 0:
+        print("Connected successfully.")
+    else:
+        print(f"Connected with result code {rc}")
+
+client.on_connect = on_connect
+client.connect(MQTT_BROKER, MQTT_PORT, 60)
+client.loop_forever()
+

docker-compose.yml

@@ -52,6 +52,12 @@ services:
         limits:
           cpus: '0.9'
           memory: 5000M
+    #healthcheck:
+    #  test: ["CMD", "curl", "-f", "http://localhost:5000/api/version"]
+    #  interval: 30s
+    #  timeout: 10s
+    #  retries: 5
+    #  start_period: 30s
 
   dayglo_detector:
     container_name: dayglo_detector
@@ -60,6 +66,7 @@ services:
     restart: always
     volumes:
       - /etc/localtime:/etc/localtime:ro
+      - /home/docker/compose/frigate/debug-image/:/tmp/debug-image/
     environment:
       MQTT_BROKER: '10.59.221.172'
       MQTT_PORT: '1883'
@@ -67,8 +74,9 @@ services:
       MQTT_PASSWORD: 'RadGawlEikWothecOmtAmmoihumid8'
       FRIGATE_URL: 'http://frigate:5000'
       INTERESTED_ZONES: 'Door_Front'
-    depends_on:
+    #depends_on:
-      - frigate
+    #  frigate:
+    #    condition: service_healthy
 
 volumes:
   frigate-config: