update

app.py

@@ -89,31 +89,76 @@ def get_points_from_contours(contours):
     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()
+# 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)
+#     # 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')
+#     # 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])
+# # 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)
+#     # 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
+#     # 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)
+#     # Display the image with the selected quadrilateral
+#     display_image_with_quadrilateral(base_image, quad_points)
+
+def get_centroid(contour):
+    # Compute the centroid for the contour
+    M = cv2.moments(contour)
+    if M["m00"] != 0:
+        return (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
+    return None
+
+def get_points_from_contours(contours):
+    centroids = [get_centroid(contour) for contour in contours if get_centroid(contour) is not None]
+    return centroids
+
+def sort_points_clockwise(centroids):
+    # Compute the centroid of the centroids
+    centroid_x = sum(x for x, y in centroids) / len(centroids)
+    centroid_y = sum(y for x, y in centroids) / len(centroids)
+    # Sort the centroids
+    centroids.sort(key=lambda point: (-math.atan2(point[1] - centroid_y, point[0] - centroid_x)) % (2 * np.pi))
+    return centroids
+
+def create_polygon_mask(centroids, flag_mask_shape):
+    # Create a polygon mask using the sorted centroids
+    poly_mask = np.zeros(flag_mask_shape, dtype=np.uint8)
+    cv2.fillPoly(poly_mask, [np.array(centroids)], 255)
+    return poly_mask
+
+def warp_and_display_images(img, centroids, base_name, flag_mask_rgb, plant_mask_rgb, mask_plant_plot_rgb):
+    # Warp the images
+    plant_rgb_warp = warp_image(img, centroids)
+    plant_mask_warp = warp_image(mask_plant_plot_rgb, centroids)
+
+    # Extract the RGB pixels from the original image using the mask_plant_plot
+    plant_rgb = cv2.bitwise_and(img, img, mask=create_polygon_mask(centroids, img.shape[:2]))
+
+    # Draw the bounding quadrilateral
+    plot_rgb = plant_rgb.copy()
+    for i in range(4):
+        cv2.line(plot_rgb, centroids[i], centroids[(i+1)%4], (0, 0, 255), 3)
+
+    # Display the images
+    st.image([flag_mask_rgb, plant_mask_rgb, mask_plant_plot_rgb, plot_rgb, plant_rgb_warp, plant_mask_warp], 
+             caption=["Flag Mask", "Plant Mask", "Mask Plant Plot", "Plot RGB", "Plant RGB Warp", "Plant Mask Warp"],
+             use_column_width=True)
+
+    return plant_rgb, plot_rgb, plant_rgb_warp, plant_mask_warp
 
 def process_image(image_path, flag_lower, flag_upper, plant_lower, plant_upper, loc):
     with loc:
@@ -158,16 +203,15 @@ def process_image(image_path, flag_lower, flag_upper, plant_lower, plant_upper,
     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 = []
     if len(significant_contours) < 4:
+        st.error("Not enough points to form a quadrilateral.")
         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
-
+        selected_quad_index = 0  # Placeholder for quadrilateral indices
+        centroids = get_points_from_contours(point_combinations[selected_quad_index])
+        centroids = sort_points_clockwise(centroids)
         # Function to update displayed quadrilateral based on selected index
         def update_displayed_quadrilateral(index):
             # Extract the four points of the current quadrilateral
@@ -188,110 +232,44 @@ def process_image(image_path, flag_lower, flag_upper, plant_lower, plant_upper,
             if st.button('Next'):
                 selected_quad_index = min(selected_quad_index + 1, len(point_combinations) - 1)
                 centroids = update_displayed_quadrilateral(selected_quad_index)
-        #############
-        # Compute the centroid of the centroids
-        centroid_x = sum(x for x, y in centroids) / 4
-        centroid_y = sum(y for x, y in centroids) / 4
-
-        # Sort the centroids
-        centroids.sort(key=lambda point: (-math.atan2(point[1] - centroid_y, point[0] - centroid_x)) % (2 * np.pi))
-
-        # Create a polygon mask using the sorted centroids
-        poly_mask = np.zeros_like(flag_mask)
-        cv2.fillPoly(poly_mask, [np.array(centroids)], 255)
-        
-        # Mask the plant_mask with poly_mask
-        mask_plant_plot = cv2.bitwise_and(plant_mask, plant_mask, mask=poly_mask)
-
-        # Count the number of black pixels inside the quadrilateral
-        total_pixels_in_quad = np.prod(poly_mask.shape)
-        white_pixels_in_quad = np.sum(poly_mask == 255)
-        black_pixels_in_quad = total_pixels_in_quad - white_pixels_in_quad
-        
-        # Extract the RGB pixels from the original image using the mask_plant_plot
-        plant_rgb = cv2.bitwise_and(img, img, mask=mask_plant_plot)
-
-        # Draw the bounding quadrilateral
-        plot_rgb = plant_rgb.copy()
-        for i in range(4):
-            cv2.line(plot_rgb, centroids[i], centroids[(i+1)%4], (0, 0, 255), 3)
-
-        # Convert the masks to RGB for visualization
-        flag_mask_rgb = cv2.cvtColor(flag_mask, cv2.COLOR_GRAY2RGB)
-        orange_color = [255, 165, 0]  # RGB value for orange
-        flag_mask_rgb[np.any(flag_mask_rgb != [0, 0, 0], axis=-1)] = orange_color
-
-        plant_mask_rgb = cv2.cvtColor(plant_mask, cv2.COLOR_GRAY2RGB)
-        mask_plant_plot_rgb = cv2.cvtColor(mask_plant_plot, cv2.COLOR_GRAY2RGB)
-        bright_green_color = [0, 255, 0]
-        plant_mask_rgb[np.any(plant_mask_rgb != [0, 0, 0], axis=-1)] = bright_green_color
-        mask_plant_plot_rgb[np.any(mask_plant_plot_rgb != [0, 0, 0], axis=-1)] = bright_green_color
-        
-        # Warp the images
-        plant_rgb_warp = warp_image(plant_rgb, centroids)
-        plant_mask_warp = warp_image(mask_plant_plot_rgb, centroids)
+    else:
+        centroids = get_points_from_contours(significant_contours)
+        centroids = sort_points_clockwise(centroids)
 
-        return flag_mask_rgb, pla
+    poly_mask = create_polygon_mask(centroids, flag_mask.shape)
 
-    # 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
-        centroid_y = sum(y for x, y in centroids) / 4
-
-        # Sort the centroids
-        centroids.sort(key=lambda point: (-math.atan2(point[1] - centroid_y, point[0] - centroid_x)) % (2 * np.pi))
-
-        # Create a polygon mask using the sorted centroids
-        poly_mask = np.zeros_like(flag_mask)
-        cv2.fillPoly(poly_mask, [np.array(centroids)], 255)
-        
-        # Mask the plant_mask with poly_mask
-        mask_plant_plot = cv2.bitwise_and(plant_mask, plant_mask, mask=poly_mask)
+    # Mask the plant_mask with poly_mask
+    mask_plant_plot = cv2.bitwise_and(plant_mask, plant_mask, mask=poly_mask)
 
-        # Count the number of black pixels inside the quadrilateral
-        total_pixels_in_quad = np.prod(poly_mask.shape)
-        white_pixels_in_quad = np.sum(poly_mask == 255)
-        black_pixels_in_quad = total_pixels_in_quad - white_pixels_in_quad
-        
-        # Extract the RGB pixels from the original image using the mask_plant_plot
-        plant_rgb = cv2.bitwise_and(img, img, mask=mask_plant_plot)
-
-        # Draw the bounding quadrilateral
-        plot_rgb = plant_rgb.copy()
-        for i in range(4):
-            cv2.line(plot_rgb, centroids[i], centroids[(i+1)%4], (0, 0, 255), 3)
-
-        # Convert the masks to RGB for visualization
-        flag_mask_rgb = cv2.cvtColor(flag_mask, cv2.COLOR_GRAY2RGB)
-        orange_color = [255, 165, 0]  # RGB value for orange
-        flag_mask_rgb[np.any(flag_mask_rgb != [0, 0, 0], axis=-1)] = orange_color
-
-        plant_mask_rgb = cv2.cvtColor(plant_mask, cv2.COLOR_GRAY2RGB)
-        mask_plant_plot_rgb = cv2.cvtColor(mask_plant_plot, cv2.COLOR_GRAY2RGB)
-        bright_green_color = [0, 255, 0]
-        plant_mask_rgb[np.any(plant_mask_rgb != [0, 0, 0], axis=-1)] = bright_green_color
-        mask_plant_plot_rgb[np.any(mask_plant_plot_rgb != [0, 0, 0], axis=-1)] = bright_green_color
-        
-        # Warp the images
-        plant_rgb_warp = warp_image(plant_rgb, centroids)
-        plant_mask_warp = warp_image(mask_plant_plot_rgb, centroids)
+    # Count the number of black pixels inside the quadrilateral
+    total_pixels_in_quad = np.prod(poly_mask.shape)
+    white_pixels_in_quad = np.sum(poly_mask == 255)
+    black_pixels_in_quad = total_pixels_in_quad - white_pixels_in_quad
+    
+    # Extract the RGB pixels from the original image using the mask_plant_plot
+    plant_rgb = cv2.bitwise_and(img, img, mask=mask_plant_plot)
+
+    # Draw the bounding quadrilateral
+    plot_rgb = plant_rgb.copy()
+    for i in range(4):
+        cv2.line(plot_rgb, centroids[i], centroids[(i+1)%4], (0, 0, 255), 3)
+
+    # Convert the masks to RGB for visualization
+    flag_mask_rgb = cv2.cvtColor(flag_mask, cv2.COLOR_GRAY2RGB)
+    orange_color = [255, 165, 0]  # RGB value for orange
+    flag_mask_rgb[np.any(flag_mask_rgb != [0, 0, 0], axis=-1)] = orange_color
+
+    plant_mask_rgb = cv2.cvtColor(plant_mask, cv2.COLOR_GRAY2RGB)
+    mask_plant_plot_rgb = cv2.cvtColor(mask_plant_plot, cv2.COLOR_GRAY2RGB)
+    bright_green_color = [0, 255, 0]
+    plant_mask_rgb[np.any(plant_mask_rgb != [0, 0, 0], axis=-1)] = bright_green_color
+    mask_plant_plot_rgb[np.any(mask_plant_plot_rgb != [0, 0, 0], axis=-1)] = bright_green_color
+    
+    # Warp the images
+    plant_rgb_warp = warp_image(plant_rgb, centroids)
+    plant_mask_warp = warp_image(mask_plant_plot_rgb, centroids)
 
-        return flag_mask_rgb, plant_mask_rgb, mask_plant_plot_rgb, plant_rgb, plot_rgb, plant_rgb_warp, plant_mask_warp, plant_mask, mask_plant_plot, black_pixels_in_quad
+    return flag_mask_rgb, plant_mask_rgb, mask_plant_plot_rgb, plant_rgb, plot_rgb, plant_rgb_warp, plant_mask_warp, plant_mask, mask_plant_plot, black_pixels_in_quad
 
 def calculate_coverage(mask_plant_plot, plant_mask_warp, black_pixels_in_quad):
     # Calculate the percentage of white pixels for mask_plant_plot