update

app.py

@@ -188,6 +188,50 @@ 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)
+
+        return flag_mask_rgb, pla
 
     # If there are exactly 4 largest contours, proceed with existing logic
     elif len(significant_contours) == 4:
@@ -204,50 +248,50 @@ def process_image(image_path, flag_lower, flag_upper, plant_lower, plant_upper,
             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
+        ########################
+        # 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))
+        # 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)
+        # 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)
+        # 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