(feat) update neg process

app.py

@@ -34,14 +34,15 @@ def load_model():
 
 import numpy as np
 
-def filter_points_by_negative(points, neg_points, distance_threshold=0.05):
+def filter_points_by_negative(points, neg_points, image_size, pixel_threshold=5):
     """
     Filter out positive points that are too close to any negative point.
     
     Args:
-        points: List of [x, y] positive points (normalized coordinates)
-        neg_points: List of [x, y] negative points (normalized coordinates)
-        distance_threshold: Minimum distance threshold (in normalized coords)
+        points: List of [x, y] positive points (normalized coordinates, 0-1)
+        neg_points: List of [x, y] negative points (normalized coordinates, 0-1)
+        image_size: Tuple of (width, height) in pixels
+        pixel_threshold: Minimum distance threshold in pixels
     
     Returns:
         filtered_points: List of points that are far enough from all negative points
@@ -50,19 +51,24 @@ def filter_points_by_negative(points, neg_points, distance_threshold=0.05):
     if not neg_points or not points:
         return points, list(range(len(points)))
     
-    points_arr = np.array(points)  # (N, 2)
-    neg_points_arr = np.array(neg_points)  # (M, 2)
+    width, height = image_size
     
-    # Compute pairwise distances: (N, M)
-    # Using broadcasting: (N, 1, 2) - (1, M, 2) -> (N, M, 2) -> (N, M)
-    diff = points_arr[:, None, :] - neg_points_arr[None, :, :]
+    points_arr = np.array(points)  # (N, 2) normalized
+    neg_points_arr = np.array(neg_points)  # (M, 2) normalized
+    
+    # Convert to pixel coordinates
+    points_pixel = points_arr * np.array([width, height])  # (N, 2)
+    neg_points_pixel = neg_points_arr * np.array([width, height])  # (M, 2)
+    
+    # Compute pairwise distances in pixels: (N, M)
+    diff = points_pixel[:, None, :] - neg_points_pixel[None, :, :]
     distances = np.linalg.norm(diff, axis=-1)  # (N, M)
     
     # Find minimum distance to any negative point for each positive point
     min_distances = distances.min(axis=1)  # (N,)
     
     # Keep points where min distance > threshold
-    keep_mask = min_distances > distance_threshold
+    keep_mask = min_distances > pixel_threshold
     
     filtered_points = points_arr[keep_mask].tolist()
     filtered_indices = np.where(keep_mask)[0].tolist()
@@ -161,10 +167,12 @@ def count_objects(image, pos_caption, neg_caption, box_threshold, point_radius,
         neg_boxes = [box.tolist() for box in neg_boxes]
         neg_points = [[box[0], box[1]] for box in neg_boxes]
     
+    img_size = image.size
     filtered_points, kept_indices = filter_points_by_negative(
         points, 
         neg_points, 
-        distance_threshold=0.05
+        image_size=img_size,
+        pixel_threshold=5
     )
     
     filtered_boxes = [boxes[i] for i in kept_indices]