Update services/plantation/missing_patch_check.py

services/plantation/missing_patch_check.py

@@ -1,85 +1,81 @@
 import cv2
 import numpy as np
-from ultralytics import YOLO
-import os
 import logging
-from typing import Tuple, List, Dict, Any
+from typing import List, Dict, Tuple
 
-# Configure logging
+# Setup logging
 logging.basicConfig(
     filename="app.log",
     level=logging.INFO,
     format="%(asctime)s - %(levelname)s - %(message)s"
 )
 
-# Define base directory and model path
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-MODEL_PATH = os.path.abspath(os.path.join(BASE_DIR, "../../models/yolov8n.pt"))
-
-# Initialize YOLO model
-try:
-    model = YOLO(MODEL_PATH)
-    logging.info("Loaded YOLOv8n model for missing patch detection.")
-    logging.info(f"Model class names: {model.names}")
-except Exception as e:
-    logging.error(f"Failed to load YOLOv8n model: {str(e)}")
-    model = None
-
-def process_missing_patches(frame: np.ndarray) -> Tuple[List[Dict[str, Any]], np.ndarray]:
-    # Validate input frame
-    if not isinstance(frame, np.ndarray) or frame.size == 0:
-        logging.error("Invalid input frame provided to missing_patch_check.")
-        return [], frame
-
-    # Check if model is loaded
-    if model is None:
-        logging.error("YOLO model not loaded. Skipping missing patch detection.")
-        return [], frame
-
+def process_missing_patches(frame: np.ndarray) -> Tuple[List[Dict], np.ndarray]:
+    """
+    Process a frame to identify missing patches in a plantation.
+    Args:
+        frame: Input frame (BGR numpy array)
+    Returns:
+        Tuple: (List of missing patch detections, annotated frame)
+    """
     try:
-        # Perform YOLO inference
-        results = model(frame, verbose=False)
-        logging.debug("Completed YOLO inference for missing patch detection.")
-    except Exception as e:
-        logging.error(f"Error during YOLO inference: {str(e)}")
-        return [], frame
+        # Convert frame to HSV and detect green regions (trees)
+        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+        lower_green = np.array([35, 40, 40])
+        upper_green = np.array([85, 255, 255])
+        mask = cv2.inRange(hsv, lower_green, upper_green)
 
-    detections: List[Dict[str, Any]] = []
-    line_counter = 1
-
-    for r in results:
-        for box in r.boxes:
-            conf = float(box.conf[0])
-            if conf < 0.3:
-                continue
-            cls = int(box.cls[0])
-            label = model.names[cls]
-            if label != "missing_patch":
+        # Find contours of trees
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        tree_positions = []
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            if area < 300:
                 continue
-            xyxy = box.xyxy[0].cpu().numpy().astype(int)
-            x_min, y_min, x_max, y_max = xyxy
+            x, y, w, h = cv2.boundingRect(contour)
+            tree_positions.append((x + w // 2, y + h // 2))
 
-            detection_label = f"Line {line_counter} - Missing Patch (Conf: {conf:.2f})"
-            detections.append({
-                "type": "missing_patch",
-                "label": detection_label,
-                "confidence": conf,
-                "coordinates": [x_min, y_min, x_max, y_max]
-            })
+        # Assume a grid-like plantation pattern and detect gaps
+        detections = []
+        if tree_positions:
+            # Estimate grid spacing by calculating average distance between trees
+            if len(tree_positions) > 1:
+                distances = []
+                for i in range(len(tree_positions)):
+                    for j in range(i + 1, len(tree_positions)):
+                        p1, p2 = tree_positions[i], tree_positions[j]
+                        dist = np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
+                        distances.append(dist)
+                avg_spacing = np.mean(distances) if distances else 100
 
-            color = (255, 165, 0)  # Orange for missing patches
-            cv2.rectangle(frame, (x_min, y_min), (x_max, y_max), color, 2)
-            cv2.putText(
-                frame,
-                detection_label,
-                (x_min, y_min - 10),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.6,
-                color,
-                2
-            )
-            
-            line_counter += 1
+                # Create a grid based on frame dimensions and avg_spacing
+                height, width = frame.shape[:2]
+                grid_step = int(avg_spacing)
+                for y in range(0, height, grid_step):
+                    for x in range(0, width, grid_step):
+                        # Check if there's a tree within this grid cell
+                        has_tree = False
+                        for tx, ty in tree_positions:
+                            if (x - grid_step // 2 <= tx <= x + grid_step // 2 and
+                                y - grid_step // 2 <= ty <= y + grid_step // 2):
+                                has_tree = True
+                                break
+                        if not has_tree:
+                            # Mark as missing patch
+                            x_min, y_min = x - grid_step // 2, y - grid_step // 2
+                            x_max, y_max = x + grid_step // 2, y + grid_step // 2
+                            detections.append({
+                                "type": "missing_patch",
+                                "label": "Missing Patch",
+                                "box": [x_min, y_min, x_max, y_max]
+                            })
+                            cv2.rectangle(frame, (x_min, y_min), (x_max, y_max), (0, 0, 255), 2)
+                            cv2.putText(frame, "Missing", (x_min, y_min - 10),
+                                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
 
-    logging.info(f"Detected {len(detections)} missing patches in plantation.")
-    return detections, frame
+        logging.info(f"Detected {len(detections)} missing patches in frame.")
+        return detections, frame
+
+    except Exception as e:
+        logging.error(f"Error in missing patch check: {str(e)}")
+        return [], frame