update

app.py

@@ -126,13 +126,16 @@ 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
+# Function to check if a quadrilateral is valid (i.e., no sides intersect)
+def is_valid_quadrilateral(pts):
+    def ccw(A, B, C):
+        return (C[1] - A[1]) * (B[0] - A[0]) > (B[1] - A[1]) * (C[0] - A[0])
+
+    def intersect(A, B, C, D):
+        return ccw(A, C, D) != ccw(B, C, D) and ccw(A, B, C) != ccw(A, B, D)
+
+    A, B, C, D = pts
+    return not (intersect(A, B, C, D) or intersect(A, D, B, C))
 
 def create_polygon_mask(centroids, flag_mask_shape):
     # Create a polygon mask using the sorted centroids
@@ -204,37 +207,39 @@ def process_image(image_path, flag_lower, flag_upper, plant_lower, plant_upper,
 
     # Logic to handle cases where there are more than 4 significant contours
     if len(significant_contours) < 4:
-        st.error("Not enough points to form a quadrilateral.")
+        with loc:
+            st.info("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))
-        selected_quad_index = 0  # Placeholder for quadrilateral indices
-        centroids = get_points_from_contours(point_combinations[selected_quad_index])
-        centroids = sort_points_clockwise(centroids)
+    else:
+        # Generate all permutations of four points
+        permutations_of_four = list(itertools.permutations(significant_contours, 4))
+        valid_quadrilaterals = [perm for perm in permutations_of_four if is_valid_quadrilateral(get_points_from_contours(perm))]
+        
+        if not valid_quadrilaterals:
+            with loc:
+                st.info("No valid quadrilaterals found.")
+            return None, None, None, None, None, None, None, None, None, None
+        
+        # Initial quadrilateral index
+        selected_quad_index = 0
+        centroids = get_points_from_contours(valid_quadrilaterals[selected_quad_index]))
         # 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])
+            centroids = get_points_from_contours(valid_quadrilaterals[index])
             return centroids
 
         # Show initial quadrilateral
         centroids = update_displayed_quadrilateral(selected_quad_index)
 
         with btn_back:
-            # 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)
-
+                update_displayed_quadrilateral(selected_quad_index)
         with btn_next:
-            # 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)
-    else:
-        centroids = get_points_from_contours(significant_contours)
-        centroids = sort_points_clockwise(centroids)
+                selected_quad_index = min(selected_quad_index + 1, len(valid_quadrilaterals) - 1)
+                update_displayed_quadrilateral(selected_quad_index)
 
     poly_mask = create_polygon_mask(centroids, flag_mask.shape)