Update app.py

app.py

@@ -1,10 +1,7 @@
-import sys
-sys.stdout.reconfigure(line_buffering=True) 
-
 # --------------------------------------------------------------------------
 # UNIFIED AI SERVICE FOR LOST & FOUND V2
 # --------------------------------------------------------------------------
-# This Flask application combines two matching engines:
+# This Flask application combines two matching engines into a single service:
 # 1. Text Engine: Analyzes structured text fields (brand, material, etc.)
 #    using text embeddings and specific comparison logic.
 # 2. Image Engine: Analyzes multiple images per item by segmenting the
@@ -42,7 +39,7 @@ app = Flask(__name__)
 TEXT_FIELD_WEIGHTS = { "brand": 1.0, "material": 1.0, "markings": 1.0, "colors": 1.0, "size": 1.0 }
 TEXT_FIELDS_TO_EMBED = ["brand", "material", "markings"]
 SCORE_WEIGHTS = { "text_score": 0.5, "image_score": 0.5 }
-FINAL_SCORE_THRESHOLD = 0.55 # A higher threshold for better quality matches
+FINAL_SCORE_THRESHOLD = 0.55
 
 # --- Model Loading ---
 print("="*50)
@@ -77,8 +74,7 @@ print("="*50)
 # ==========================================================================
 
 # --- Text Processing Helpers ---
-def get_text_embedding(text: str) -> np.ndarray:
-    """Generates a normalized embedding for a given text string."""
+def get_text_embedding(text: str) -> list:
     if not text or not text.strip(): return None
     instruction = "Represent this sentence for searching relevant passages: "
     inputs = tokenizer_text(instruction + text, return_tensors='pt', padding=True, truncation=True, max_length=512).to(device)
@@ -86,16 +82,14 @@ def get_text_embedding(text: str) -> np.ndarray:
         outputs = model_text(**inputs)
     embedding = outputs.last_hidden_state[:, 0, :]
     embedding = torch.nn.functional.normalize(embedding, p=2, dim=1)
-    return embedding.cpu().numpy()[0]
+    return embedding.cpu().numpy()[0].tolist()
 
 def cosine_similarity(vec1, vec2):
-    """Calculates cosine similarity between two vectors."""
     if vec1 is None or vec2 is None: return 0.0
     vec1, vec2 = np.array(vec1), np.array(vec2)
     return float(np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2)))
 
 def calculate_color_similarity(colors1: list, colors2: list) -> float:
-    """Calculates Jaccard similarity for two lists of colors."""
     if not colors1 and not colors2: return 1.0
     if not colors1 or not colors2: return 0.0
     set1, set2 = set(c.lower() for c in colors1), set(c.lower() for c in colors2)
@@ -105,7 +99,6 @@ def calculate_color_similarity(colors1: list, colors2: list) -> float:
 
 # --- Image Processing Helpers ---
 def segment_guided_object(image: Image.Image, object_label: str) -> Image.Image:
-    """Segments an object from an image using a text label."""
     prompt = f"a {object_label}."
     image_rgb = image.convert("RGB")
     image_np = np.array(image_rgb)
@@ -120,10 +113,11 @@ def segment_guided_object(image: Image.Image, object_label: str) -> Image.Image:
     )
 
     if not results or len(results[0]['boxes']) == 0:
-        return image # Return full image if object not detected
+        print(f"  [Segment] ⚠️ Warning: Could not detect '{object_label}'. Using full image.")
+        return image
 
     sam_predictor.set_image(image_np)
-    box = results[0]['boxes'][0].cpu().numpy().astype(int) # Use the highest confidence box
+    box = results[0]['boxes'][0].cpu().numpy().astype(int)
     masks, _, _ = sam_predictor.predict(box=box, multimask_output=False)
     
     mask = masks[0]
@@ -134,12 +128,10 @@ def segment_guided_object(image: Image.Image, object_label: str) -> Image.Image:
     return Image.fromarray(object_rgba, 'RGBA')
 
 def extract_visual_features(segmented_image_rgba: Image.Image) -> dict:
-    """Extracts shape, color, and texture features from a segmented RGBA image."""
     image_np = np.array(segmented_image_rgba)
     bgr_image = cv2.cvtColor(image_np[:, :, :3], cv2.COLOR_RGB2BGR)
     mask = image_np[:, :, 3]
 
-    # Shape Features (Hu Moments)
     contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     shape_features = np.zeros(7)
     if contours:
@@ -149,11 +141,9 @@ def extract_visual_features(segmented_image_rgba: Image.Image) -> dict:
             hu_moments = cv2.HuMoments(moments).flatten()
             shape_features = -np.sign(hu_moments) * np.log10(np.abs(hu_moments) + 1e-7)
 
-    # Color Features (3D Histogram)
     color_hist = cv2.calcHist([bgr_image], [0, 1, 2], mask, [8, 8, 8], [0, 256, 0, 256, 0, 256])
     cv2.normalize(color_hist, color_hist)
     
-    # Texture Features (Local Binary Pattern)
     gray_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2GRAY)
     lbp = feature.local_binary_pattern(gray_image, P=24, R=3, method="uniform")
     (texture_hist, _) = np.histogram(lbp[mask > 0], bins=np.arange(0, 27), range=(0, 26))
@@ -167,7 +157,6 @@ def extract_visual_features(segmented_image_rgba: Image.Image) -> dict:
     }
 
 def calculate_dynamic_weights(all_shape_scores, all_color_scores, stability_factor=0.4):
-    """Calculates robust dynamic weights based on score dispersion."""
     shape_scores, color_scores = np.array(all_shape_scores), np.array(all_color_scores)
     
     def get_iqr(scores):
@@ -177,13 +166,10 @@ def calculate_dynamic_weights(all_shape_scores, all_color_scores, stability_fact
 
     shape_dispersion = get_iqr(shape_scores)
     color_dispersion = get_iqr(color_scores)
-
     inv_shape_disp = 1 / (shape_dispersion + stability_factor)
     inv_color_disp = 1 / (color_dispersion + stability_factor)
-    
     total_inv_disp = inv_shape_disp + inv_color_disp
-    
-    remaining_weight = 0.8 # Texture is fixed at 0.2
+    remaining_weight = 0.8
     
     shape_weight = remaining_weight * (inv_shape_disp / total_inv_disp) if total_inv_disp > 0 else remaining_weight / 2
     color_weight = remaining_weight * (inv_color_disp / total_inv_disp) if total_inv_disp > 0 else remaining_weight / 2
@@ -200,40 +186,43 @@ def health_check():
 
 @app.route('/process', methods=['POST'])
 def process_item():
-    """
-    Receives item data (text fields + image URLs) and returns a
-    JSON object enriched with all extracted AI features.
-    """
     try:
         data = request.json
         print(f"\n[PROCESS] Received request for object: {data.get('objectName')}")
         
         # --- 1. Process Text Features ---
+        print("  [PROCESS] Generating text embeddings...")
         response = {
             "canonicalLabel": data.get('objectName', '').lower().strip(),
             "brand_embedding": get_text_embedding(data.get('brand')),
             "material_embedding": get_text_embedding(data.get('material')),
             "markings_embedding": get_text_embedding(data.get('markings'))
         }
+        print("  [PROCESS] ✅ Text embeddings generated.")
 
         # --- 2. Process Image Features ---
         visual_features_list = []
         if data.get('images'):
-            for image_url in data['images']:
+            print(f"  [PROCESS] Processing {len(data['images'])} image(s)...")
+            for i, image_url in enumerate(data['images']):
                 try:
+                    print(f"    - Processing image {i+1}: {image_url}")
                     img_response = requests.get(image_url, timeout=20)
                     img_response.raise_for_status()
                     image = Image.open(BytesIO(img_response.content))
                     
+                    print("      - Segmenting object...")
                     segmented_image = segment_guided_object(image, data['objectName'])
+                    print("      - Extracting visual features...")
                     features = extract_visual_features(segmented_image)
                     visual_features_list.append(features)
+                    print(f"    - ✅ Image {i+1} processed.")
                 except Exception as e:
-                    print(f"  [PROCESS] ⚠️ Could not process image {image_url}: {e}")
+                    print(f"    - ⚠️ Could not process image {image_url}: {e}")
                     continue
         
         response["visual_features"] = visual_features_list
-        print(f"  [PROCESS] ✅ Successfully processed features.")
+        print(f"  [PROCESS] ✅ Successfully processed all features.")
         return jsonify(response), 200
 
     except Exception as e:
@@ -243,10 +232,6 @@ def process_item():
 
 @app.route('/compare', methods=['POST'])
 def compare_items():
-    """
-    Receives a query item and a list of search items, and returns
-    a list of potential matches based on a hybrid score.
-    """
     try:
         payload = request.json
         query_item = payload['queryItem']
@@ -255,11 +240,12 @@ def compare_items():
         
         results = []
         for item in search_list:
+            item_id = item.get('_id')
+            print(f"\n  - Comparing with item: {item_id} ({item.get('objectName')})")
             try:
                 # --- 1. Calculate Text Score ---
                 total_text_score, total_text_weight = 0, 0
                 
-                # Compare embeddings
                 for field in TEXT_FIELDS_TO_EMBED:
                     q_emb = query_item.get(f"{field}_embedding")
                     i_emb = item.get(f"{field}_embedding")
@@ -269,21 +255,20 @@ def compare_items():
                         total_text_score += score * weight
                         total_text_weight += weight
                 
-                # Compare colors
                 if query_item.get('colors'):
                     score = calculate_color_similarity(query_item['colors'], item.get('colors', []))
                     weight = TEXT_FIELD_WEIGHTS.get('colors', 0)
                     total_text_score += score * weight
                     total_text_weight += weight
 
-                # Compare size
                 if query_item.get('size'):
-                    score = 1.0 if query_item['size'] == item.get('size') else 0.0
+                    score = 1.0 if query_item.get('size') == item.get('size') else 0.0
                     weight = TEXT_FIELD_WEIGHTS.get('size', 0)
                     total_text_score += score * weight
                     total_text_weight += weight
 
                 text_score = (total_text_score / total_text_weight) if total_text_weight > 0 else 0.0
+                print(f"    - Text Score: {text_score:.4f}")
 
                 # --- 2. Calculate Image Score ---
                 image_score = 0.0
@@ -292,15 +277,11 @@ def compare_items():
 
                 if query_visuals and item_visuals:
                     all_shape_scores, all_color_scores, all_texture_scores = [], [], []
-                    
                     for q_vis in query_visuals:
                         for i_vis in item_visuals:
-                            # Shape comparison
                             shape_dist = cv2.matchShapes(np.array(q_vis["shape_features"], dtype="float32"), np.array(i_vis["shape_features"], dtype="float32"), cv2.CONTOURS_MATCH_I1, 0.0)
                             all_shape_scores.append(1.0 / (1.0 + shape_dist))
-                            # Color comparison
                             all_color_scores.append(cv2.compareHist(np.array(q_vis["color_features"], dtype="float32"), np.array(i_vis["color_features"], dtype="float32"), cv2.HISTCMP_CORREL))
-                            # Texture comparison
                             all_texture_scores.append(cv2.compareHist(np.array(q_vis["texture_features"], dtype="float32"), np.array(i_vis["texture_features"], dtype="float32"), cv2.HISTCMP_CORREL))
 
                     if all_shape_scores:
@@ -308,21 +289,28 @@ def compare_items():
                         image_score = (weights["shape"] * max(all_shape_scores) +
                                        weights["color"] * max(all_color_scores) +
                                        weights["texture"] * max(all_texture_scores))
+                print(f"    - Image Score: {image_score:.4f}")
                 
                 # --- 3. Calculate Final Hybrid Score ---
-                final_score = (SCORE_WEIGHTS['text_score'] * text_score + SCORE_WEIGHTS['image_score'] * image_score)
-                if not query_visuals or not item_visuals:
+                if query_visuals and item_visuals:
+                    final_score = (SCORE_WEIGHTS['text_score'] * text_score + SCORE_WEIGHTS['image_score'] * image_score)
+                else:
                     final_score = text_score # Default to text score if one has no image
+                
+                print(f"    - Final Hybrid Score: {final_score:.4f}")
 
                 if final_score >= FINAL_SCORE_THRESHOLD:
-                    results.append({ "_id": str(item['_id']), "score": round(final_score, 4) })
+                    print(f"    - ✅ ACCEPTED (Score >= {FINAL_SCORE_THRESHOLD})")
+                    results.append({ "_id": str(item_id), "score": round(final_score, 4) })
+                else:
+                    print(f"    - ❌ REJECTED (Score < {FINAL_SCORE_THRESHOLD})")
 
             except Exception as e:
-                print(f"  [COMPARE] ⚠️ Skipping item {item.get('_id')} due to error: {e}")
+                print(f"    - ⚠️ Skipping item {item_id} due to error: {e}")
                 continue
         
         results.sort(key=lambda x: x["score"], reverse=True)
-        print(f"  [COMPARE] ✅ Search complete. Found {len(results)} potential matches.")
+        print(f"\n[COMPARE] ✅ Search complete. Found {len(results)} potential matches.")
         return jsonify({"matches": results}), 200
 
     except Exception as e: