Update services/plantation/missing_patch_check.py

services/plantation/missing_patch_check.py

@@ -1,81 +1,47 @@
 import cv2
 import numpy as np
-import logging
-from typing import List, Dict, Tuple
+from typing import List, Tuple, Dict, Any
 
-# Setup logging
-logging.basicConfig(
-    filename="app.log",
-    level=logging.INFO,
-    format="%(asctime)s - %(levelname)s - %(message)s"
-)
-
-def process_missing_patches(frame: np.ndarray) -> Tuple[List[Dict], np.ndarray]:
+def process_missing_patches(frame: np.ndarray) -> Tuple[List[Dict[str, Any]], np.ndarray]:
     """
-    Process a frame to identify missing patches in a plantation.
+    Detect missing patches in the plantation area.
     Args:
-        frame: Input frame (BGR numpy array)
+        frame: Input frame as a numpy array.
     Returns:
-        Tuple: (List of missing patch detections, annotated frame)
+        Tuple of (list of detections, annotated frame).
     """
-    try:
-        # 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)
-
-        # 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
-            x, y, w, h = cv2.boundingRect(contour)
-            tree_positions.append((x + w // 2, y + h // 2))
-
-        # 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
-
-                # 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 frame.")
-        return detections, frame
-
-    except Exception as e:
-        logging.error(f"Error in missing patch check: {str(e)}")
-        return [], frame
+    # Convert to HSV color space for soil detection
+    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+    
+    # Define range for soil color (brownish tones)
+    lower_soil = np.array([10, 50, 50])
+    upper_soil = np.array([30, 255, 255])
+    mask = cv2.inRange(hsv, lower_soil, upper_soil)
+    
+    # Morphological operations to clean up the mask
+    kernel = np.ones((5, 5), np.uint8)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+    
+    # Find contours of missing patches
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    detections = []
+    for i, contour in enumerate(contours):
+        area = cv2.contourArea(contour)
+        if area < 200:  # Ignore small patches
+            continue
+        
+        x, y, w, h = cv2.boundingRect(contour)
+        x_min, y_min, x_max, y_max = x, y, x + w, y + h
+        
+        # Determine severity based on area
+        severity = "Severe" if area > 1000 else "Moderate" if area > 500 else "Mild"
+        
+        detections.append({
+            "box": [x_min, y_min, x_max, y_max],
+            "label": "Missing",
+            "type": "missing_patch",
+            "severity": severity
+        })
+    
+    return detections, frame