1st

pipeline/routes.py

@@ -0,0 +1,127 @@
+# pipeline/routes.py
+import traceback
+import numpy as np
+import cv2
+from flask import request, jsonify
+
+# Import app, models, and logic functions
+from pipeline import app, models, logic
+
+@app.route('/process', methods=['POST'])
+def process_item():
+    print("\n" + "="*50)
+    print("➡ [Request] Received new request to /process")
+    try:
+        data = request.get_json()
+        if not data: return jsonify({"error": "Invalid JSON payload"}), 400
+
+        object_name = data.get('objectName')
+        description = data.get('objectDescription')
+        image_url = data.get('objectImage') 
+
+        if not all([object_name, description]):
+            return jsonify({"error": "objectName and objectDescription are required."}), 400
+
+        canonical_label = logic.get_canonical_label(object_name)
+        text_embedding = logic.get_text_embedding(description, models)
+
+        response_data = {
+            "canonicalLabel": canonical_label,
+            "text_embedding": text_embedding,
+        }
+
+        if image_url:
+            print("--- Image URL provided, processing visual features... ---")
+            image = logic.download_image_from_url(image_url)
+            object_crop = logic.detect_and_crop(image, canonical_label, models)
+            visual_features = logic.extract_features(object_crop)
+            response_data.update(visual_features)
+        else:
+            print("--- No image URL provided, skipping visual feature extraction. ---")
+
+        print("✅ Successfully processed item.")
+        print("="*50)
+        return jsonify(response_data), 200
+
+    except Exception as e:
+        print(f"❌ Error in /process: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500
+
+@app.route('/compare', methods=['POST'])
+def compare_items():
+    print("\n" + "="*50)
+    print("➡ [Request] Received new request to /compare")
+    try:
+        data = request.get_json()
+        if not data: return jsonify({"error": "Invalid JSON payload"}), 400
+
+        query_item = data.get('queryItem')
+        search_list = data.get('searchList')
+
+        if not all([query_item, search_list]):
+            return jsonify({"error": "queryItem and searchList are required."}), 400
+        
+        query_text_emb = np.array(query_item['text_embedding'])
+        results = []
+        print(f"--- Comparing 1 query item against {len(search_list)} items ---")
+
+        for item in search_list:
+            item_id = item.get('_id')
+            print(f"\n [Checking] Item ID: {item_id}")
+            try:
+                text_emb_found = np.array(item['text_embedding'])
+                text_score = logic.cosine_similarity(query_text_emb, text_emb_found)
+                print(f" - Text Score: {text_score:.4f}")
+
+                has_query_image = 'shape_features' in query_item and query_item['shape_features']
+                has_item_image = 'shape_features' in item and item['shape_features']
+
+                if has_query_image and has_item_image:
+                    print(" - Both items have images. Performing visual comparison.")
+                    from pipeline import FEATURE_WEIGHTS # Import constant
+                    query_shape = np.array(query_item['shape_features'])
+                    query_color = np.array(query_item['color_features']).astype("float32")
+                    query_texture = np.array(query_item['texture_features']).astype("float32")
+                    found_shape = np.array(item['shape_features'])
+                    found_color = np.array(item['color_features']).astype("float32")
+                    found_texture = np.array(item['texture_features']).astype("float32")
+                    shape_dist = cv2.matchShapes(query_shape, found_shape, cv2.CONTOURS_MATCH_I1, 0.0)
+                    shape_score = 1.0 / (1.0 + shape_dist)
+                    color_score = cv2.compareHist(query_color, found_color, cv2.HISTCMP_CORREL)
+                    texture_score = cv2.compareHist(query_texture, found_texture, cv2.HISTCMP_CORREL)
+                    raw_image_score = (FEATURE_WEIGHTS["shape"] * shape_score +
+                                       FEATURE_WEIGHTS["color"] * color_score +
+                                       FEATURE_WEIGHTS["texture"] * texture_score)
+                    image_score = logic.stretch_image_score(raw_image_score)
+                    final_score = 0.4 * image_score + 0.6 * text_score
+                    print(f" - Image Score: {image_score:.4f} | Final Score: {final_score:.4f}")
+                else:
+                    print(" - One or both items missing image. Using text score only.")
+                    final_score = text_score
+
+                from pipeline import FINAL_SCORE_THRESHOLD # Import constant
+                if final_score >= FINAL_SCORE_THRESHOLD:
+                    print(f" - ✅ ACCEPTED (Score >= {FINAL_SCORE_THRESHOLD})")
+                    results.append({
+                        "_id": item_id,
+                        "score": round(final_score, 4),
+                        "objectName": item.get("objectName"),
+                        "objectDescription": item.get("objectDescription"),
+                        "objectImage": item.get("objectImage"),
+                    })
+                else:
+                    print(f" - ❌ REJECTED (Score < {FINAL_SCORE_THRESHOLD})")
+            except Exception as e:
+                print(f" [Skipping] Item {item_id} due to processing error: {e}")
+                continue
+
+        results.sort(key=lambda x: x["score"], reverse=True)
+        print(f"\n✅ Search complete. Found {len(results)} potential matches.")
+        print("="*50)
+        return jsonify({"matches": results}), 200
+
+    except Exception as e:
+        print(f"❌ Error in /compare: {e}")
+        traceback.print_exc()
+        return jsonify({"error": str(e)}), 500