Upload 4 files

frige_detect/detect.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+"""
+Detect ingredients using a Roboflow model with preprocessing:
+- Resize images to 640x640 if needed.
+- Perform detection.
+- Classify object sizes via K-Means.
+- Generate JSON and annotated image outputs.
+"""
+
+import json
+import os
+import tempfile
+from dataclasses import dataclass
+
+import cv2
+import numpy as np
+from roboflow import Roboflow
+from sklearn.cluster import KMeans
+import supervision as sv
+
+
+@dataclass
+class RoboflowCredentials:
+    api_key: str
+    project_name: str
+    version: int = 1
+
+
+def load_roboflow_credentials(path: str) -> RoboflowCredentials:
+    """Load Roboflow API credentials from a simple key=value text file."""
+    if not os.path.exists(path):
+        raise FileNotFoundError(
+            f"Roboflow credential file not found: {path}."
+        )
+
+    api_key = None
+    project_name = None
+    version = 1
+
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" not in line:
+                continue
+            key, value = line.split("=", 1)
+            key = key.strip().lower()
+            value = value.strip()
+            if key == "api_key":
+                api_key = value
+            elif key == "project_name":
+                project_name = value
+            elif key == "version":
+                try:
+                    version = int(value)
+                except ValueError:
+                    raise ValueError("Version in credential file must be an integer") from None
+
+    if not api_key or not project_name:
+        raise ValueError(
+            "Credential file must contain api_key and project_name entries."
+        )
+
+    return RoboflowCredentials(api_key=api_key, project_name=project_name, version=version)
+
+def compute_area_ratios(predictions, img_shape):
+    """Compute area ratio (bbox area / image area) for each detection."""
+    img_area = float(img_shape[0] * img_shape[1])
+    ratios = []
+    for pred in predictions:
+        area = pred["width"] * pred["height"]
+        ratios.append(area / img_area)
+    return np.array(ratios).reshape(-1, 1)
+
+def cluster_sizes(area_ratios):
+    """Cluster area ratios into two groups using K-Means and return size labels."""
+    kmeans = KMeans(n_clusters=2, init="k-means++", random_state=0)
+    labels = kmeans.fit_predict(area_ratios)
+    centroids = kmeans.cluster_centers_.flatten()
+    large_cluster = np.argmax(centroids)
+    return ["large" if lbl == large_cluster else "small" for lbl in labels]
+
+def detect_and_generate(
+    image_path: str,
+    credentials: RoboflowCredentials,
+    conf_threshold: float = 0.4,
+    overlap_threshold: float = 0.3,
+    conf_split: float = 0.7,
+    output_json: str = "recipe_input.json",
+    output_image: str = "annotated_image.jpg"
+):
+    """
+    Resize image if necessary, run detection, classify sizes via K-Means, and
+    create both JSON output and annotated image.
+
+    Args:
+        image_path (str): Path to the original image.
+        api_key (str): Roboflow API key.
+        project_name (str): Roboflow project name.
+        version (int): Model version.
+        conf_threshold (float): Minimum confidence threshold (0–1).
+        overlap_threshold (float): NMS overlap threshold (0–1).
+        conf_split (float): Threshold for high/low confidence lists.
+        output_json (str): Output JSON filename.
+        output_image (str): Output annotated image filename.
+
+    Returns:
+        dict: Recipe input JSON structure.
+    """
+    # Load original image
+    original_img = cv2.imread(image_path)
+    if original_img is None:
+        raise FileNotFoundError(f"Image not found: {image_path}")
+
+    height, width = original_img.shape[:2]
+
+    # Preprocess: resize to 640x640 if needed, and save to a temp file
+    if height != 640 or width != 640:
+        resized_img = cv2.resize(original_img, (640, 640))
+        # create temporary file via mkstemp; close fd to avoid locking
+        fd, tmp_path = tempfile.mkstemp(suffix=".jpg")
+        os.close(fd)
+        cv2.imwrite(tmp_path, resized_img)
+        detection_path = tmp_path
+        img_for_annotation = resized_img
+    else:
+        detection_path = image_path
+        img_for_annotation = original_img
+
+    # Initialize Roboflow model
+    rf = Roboflow(api_key=credentials.api_key)
+    model = rf.workspace().project(credentials.project_name).version(credentials.version).model
+
+    # Run prediction
+    response = model.predict(
+        detection_path,
+        confidence=int(conf_threshold * 100),
+        overlap=int(overlap_threshold * 100)
+    ).json()
+    predictions = response["predictions"]
+
+    # Classify sizes using K-Means
+    area_ratios = compute_area_ratios(predictions, img_for_annotation.shape)
+    size_labels = cluster_sizes(area_ratios)
+
+    # Build JSON structure
+    ingredients = []
+    high_conf = []
+    low_conf = []
+    for pred, size_label in zip(predictions, size_labels):
+        name = pred["class"]
+        conf = pred["confidence"]
+        ingredients.append({
+            "name": name,
+            "quantity": size_label,
+            "confidence": round(conf, 2)
+        })
+        if conf >= conf_split:
+            high_conf.append(name)
+        else:
+            low_conf.append(name)
+
+    recipe_json = {
+        "ingredients": ingredients,
+        "high_confidence_ingredients": high_conf,
+        "low_confidence_ingredients": low_conf
+    }
+
+    # Write JSON to file
+    with open(output_json, "w", encoding="utf-8") as jf:
+        json.dump(recipe_json, jf, indent=4)
+
+    # Annotate image with bounding boxes and confidence labels
+    detections = sv.Detections.from_inference(response)
+    label_annotator = sv.LabelAnnotator()
+    box_annotator = sv.BoxAnnotator()
+
+    labels_for_annotation = [
+        f"{pred['class']} ({pred['confidence']:.2f})" for pred in predictions
+    ]
+
+    annotated_img = box_annotator.annotate(
+        scene=img_for_annotation.copy(),
+        detections=detections
+    )
+    annotated_img = label_annotator.annotate(
+        scene=annotated_img,
+        detections=detections,
+        labels=labels_for_annotation
+    )
+
+    cv2.imwrite(output_image, annotated_img)
+
+    # Display annotated image (optional, for notebooks)
+    # Clean up temporary file
+    if height != 640 or width != 640:
+        try:
+            os.remove(tmp_path)
+        except PermissionError:
+            # If still locked on Windows, delay deletion or log a warning
+            pass
+
+    return {
+        "recipe_json": recipe_json,
+        "output_json_path": output_json,
+        "annotated_image_path": output_image,
+    }

frige_detect/recipe_input.json

@@ -0,0 +1,86 @@
+{
+    "ingredients": [
+        {
+            "name": "sugar",
+            "quantity": "large",
+            "confidence": 0.91
+        },
+        {
+            "name": "chicken",
+            "quantity": "large",
+            "confidence": 0.91
+        },
+        {
+            "name": "milk",
+            "quantity": "large",
+            "confidence": 0.89
+        },
+        {
+            "name": "flour",
+            "quantity": "large",
+            "confidence": 0.88
+        },
+        {
+            "name": "eggs",
+            "quantity": "small",
+            "confidence": 0.88
+        },
+        {
+            "name": "apple",
+            "quantity": "large",
+            "confidence": 0.86
+        },
+        {
+            "name": "corn",
+            "quantity": "small",
+            "confidence": 0.85
+        },
+        {
+            "name": "blueberries",
+            "quantity": "small",
+            "confidence": 0.83
+        },
+        {
+            "name": "chicken_breast",
+            "quantity": "large",
+            "confidence": 0.82
+        },
+        {
+            "name": "ground_beef",
+            "quantity": "large",
+            "confidence": 0.81
+        },
+        {
+            "name": "beef",
+            "quantity": "large",
+            "confidence": 0.77
+        },
+        {
+            "name": "carrot",
+            "quantity": "large",
+            "confidence": 0.75
+        },
+        {
+            "name": "bread",
+            "quantity": "large",
+            "confidence": 0.51
+        }
+    ],
+    "high_confidence_ingredients": [
+        "sugar",
+        "chicken",
+        "milk",
+        "flour",
+        "eggs",
+        "apple",
+        "corn",
+        "blueberries",
+        "chicken_breast",
+        "ground_beef",
+        "beef",
+        "carrot"
+    ],
+    "low_confidence_ingredients": [
+        "bread"
+    ]
+}

frige_detect/roboflow_credentials.txt

@@ -0,0 +1,4 @@
+# Roboflow credentials used by the app and detector
+api_key=DgOLnmYH3XuE2Aikk7a6
+project_name=nutrition-object-detection
+version=1