update

app.py

@@ -1,4 +1,4 @@
-import os, math, csv, shutil
+import os, math, csv, shutil, itertools
 import streamlit as st
 from streamlit_image_select import image_select
 import cv2
@@ -10,7 +10,7 @@ from io import BytesIO
 
 MAX_GALLERY_IMAGES = 50
 GALLERY_IMAGE_SIZE = 128
-
+MIN_AREA = 10
 
 class DirectoryManager:
     def __init__(self, output_dir):
@@ -72,6 +72,49 @@ def warp_image(img, vertices):
 
     return warped_img
 
+# Assuming get_points_from_contours is a function that takes a tuple of four contours
+# and returns their respective centroid points as a list of tuples [(x1,y1), (x2,y2), (x3,y3), (x4,y4)]
+def get_points_from_contours(contours):
+    centroids = []
+    for contour in contours:
+        # Compute the centroid for the contour
+        M = cv2.moments(contour)
+        if M["m00"] != 0:
+            cX = int(M["m10"] / M["m00"])
+            cY = int(M["m01"] / M["m00"])
+            centroids.append((cX, cY))
+        else:
+            # If the contour is a single point or line (which should not happen with flags), handle it here
+            pass
+    return centroids
+
+# Function to display the image with the selected quadrilateral superimposed
+def display_image_with_quadrilateral(image, points):
+    # Make a copy of the image to draw on
+    overlay_image = image.copy()
+    
+    # Draw the quadrilateral
+    cv2.polylines(overlay_image, [np.array(points)], isClosed=True, color=(0, 255, 0), thickness=3)
+    
+    # Display the image with the quadrilateral
+    st.image(overlay_image, caption="Quadrilateral on Image", use_column_width='auto')
+
+# Function to update displayed quadrilateral based on selected index
+def update_displayed_quadrilateral(index, point_combinations, base_image_path):
+    # Extract the four points of the current quadrilateral
+    quad_points = get_points_from_contours(point_combinations[index])
+    
+    # Read the base image
+    base_image = cv2.imread(base_image_path)
+    
+    # If the image is not found, handle the error appropriately
+    if base_image is None:
+        st.error("Failed to load image.")
+        return
+    
+    # Display the image with the selected quadrilateral
+    display_image_with_quadrilateral(base_image, quad_points)
+
 def process_image(image_path, flag_lower, flag_upper, plant_lower, plant_upper):
     img = cv2.imread(image_path)
     
@@ -91,30 +134,71 @@ def process_image(image_path, flag_lower, flag_upper, plant_lower, plant_upper):
     flag_mask = cv2.inRange(hsv_img, flag_lower, flag_upper)
     plant_mask = cv2.inRange(hsv_img, plant_lower, plant_upper)
 
-    # Find contours
-    contours, _ = cv2.findContours(flag_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    # # Find contours
+    # contours, _ = cv2.findContours(flag_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     
-    # Sort contours by area and keep only the largest 4
-    sorted_contours = sorted(contours, key=cv2.contourArea, reverse=True)[:4]
+    # # Sort contours by area and keep only the largest 4
+    # sorted_contours = sorted(contours, key=cv2.contourArea, reverse=True)[:4]
     
-    # If there are not 4 largest contours, return
-    if len(sorted_contours) != 4:
-        return None, None, None, None, None, None, None, None, None, None
+    # # If there are not 4 largest contours, return
+    # if len(sorted_contours) != 4:
+    #     return None, None, None, None, None, None, None, None, None, None
 
-    # Create a new mask with only the largest 4 contours
-    largest_4_flag_mask = np.zeros_like(flag_mask)
-    cv2.drawContours(largest_4_flag_mask, sorted_contours, -1, (255), thickness=cv2.FILLED)
-    
-    # Compute the centroid for each contour
+
+    # Find contours
+    contours, _ = cv2.findContours(flag_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # Sort contours by area and keep a significant number, assuming noise has much smaller area
+    sorted_contours = sorted(contours, key=cv2.contourArea, reverse=True)
+
+    # Filter out noise based on a predefined area threshold
+    significant_contours = [cnt for cnt in sorted_contours if cv2.contourArea(cnt) > MIN_AREA]
+
+    # Logic to handle cases where there are more than 4 significant contours
     centroids = []
-    for contour in sorted_contours:
-        M = cv2.moments(contour)
-        if M["m00"] != 0:
-            cx = int(M["m10"] / M["m00"])
-            cy = int(M["m01"] / M["m00"])
-        else:
-            cx, cy = 0, 0
-        centroids.append((cx, cy))
+    if len(significant_contours) < 4:
+        return None, None, None, None, None, None, None, None, None, None
+    elif len(significant_contours) > 4:
+        # Create all possible combinations of four points
+        point_combinations = list(itertools.combinations(significant_contours, 4))
+        
+        # Placeholder for quadrilateral indices
+        selected_quad_index = 0
+
+        # Function to update displayed quadrilateral based on selected index
+        def update_displayed_quadrilateral(index):
+            # Extract the four points of the current quadrilateral
+            centroids = get_points_from_contours(point_combinations[index])
+            return centroids
+
+        # Show initial quadrilateral
+        centroids = update_displayed_quadrilateral(selected_quad_index)
+
+        # Button to go to the previous quadrilateral
+        if st.button('Previous'):
+            selected_quad_index = max(selected_quad_index - 1, 0)
+            centroids = update_displayed_quadrilateral(selected_quad_index)
+
+        # Button to go to the next quadrilateral
+        if st.button('Next'):
+            selected_quad_index = min(selected_quad_index + 1, len(point_combinations) - 1)
+            centroids = update_displayed_quadrilateral(selected_quad_index)
+
+    # If there are exactly 4 largest contours, proceed with existing logic
+    elif len(significant_contours) == 4:
+        # Create a new mask with only the largest 4 contours
+        largest_4_flag_mask = np.zeros_like(flag_mask)
+        cv2.drawContours(largest_4_flag_mask, sorted_contours, -1, (255), thickness=cv2.FILLED)
+        
+        # Compute the centroid for each contour
+        for contour in sorted_contours:
+            M = cv2.moments(contour)
+            if M["m00"] != 0:
+                cx = int(M["m10"] / M["m00"])
+                cy = int(M["m01"] / M["m00"])
+            else:
+                cx, cy = 0, 0
+            centroids.append((cx, cy))
     
     # Compute the centroid of the centroids
     centroid_x = sum(x for x, y in centroids) / 4