129 lines
4.9 KiB
Python
129 lines
4.9 KiB
Python
import cv2
|
|
import numpy as np
|
|
from typing import Dict, Any, Optional
|
|
|
|
|
|
class MicrowaveDishAnalyzer:
|
|
"""
|
|
Estimates food dish volume from top-down camera images and dish height,
|
|
and cross-validates physical volume against Edamam AI mass estimates.
|
|
"""
|
|
|
|
# Constant scale ratio: Centimeters per Pixel.
|
|
# TODO : Replace this value once your camera calibration is complete.
|
|
CM_PER_PIXEL: float = 0.05 # Example: 1 pixel = 0.05 cm
|
|
|
|
def __init__(self, cm_per_pixel: Optional[float] = None):
|
|
if cm_per_pixel is not None:
|
|
self.cm_per_pixel = cm_per_pixel
|
|
else:
|
|
self.cm_per_pixel = self.CM_PER_PIXEL
|
|
|
|
def calculate_surface_area_cm2(self, image_path: str) -> float:
|
|
"""
|
|
Segments the food/dish from the background and returns surface area in cm².
|
|
"""
|
|
image = cv2.imread(image_path)
|
|
if image is None:
|
|
raise FileNotFoundError(f"Image could not be loaded from path: {image_path}")
|
|
|
|
# 1. Convert to grayscale & blur to reduce noise
|
|
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
|
|
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
|
|
|
|
# 2. Otsu thresholding to segment foreground (dish) from background (turntable)
|
|
_, thresh = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
|
|
|
|
# 3. Find contours
|
|
contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
|
|
if not contours:
|
|
return 0.0
|
|
|
|
# 4. Assume the largest contour corresponds to the dish/food area
|
|
largest_contour = max(contours, key=cv2.contourArea)
|
|
area_pixels = cv2.contourArea(largest_contour)
|
|
|
|
# 5. Convert pixels² to cm² using scale ratio squared
|
|
area_cm2 = area_pixels * (self.cm_per_pixel ** 2)
|
|
return float(area_cm2)
|
|
|
|
@staticmethod
|
|
def _get_shape_factor(food_label: str) -> float:
|
|
"""
|
|
Selects geometric correction factor (k_shape) based on container/food shape:
|
|
- Bowls/Soups: ~0.60 (paraboloid)
|
|
- Drinks/Mugs: ~0.95 (cylinder)
|
|
- Flat plates/solid foods: ~0.85 (truncated cone / disk)
|
|
"""
|
|
label = food_label.lower()
|
|
if any(w in label for w in ["soup", "chili", "stew", "curry", "bowl"]):
|
|
return 0.60
|
|
elif any(w in label for w in ["coffee", "tea", "milk", "water", "beverage", "mug"]):
|
|
return 0.95
|
|
elif any(w in label for w in ["bread", "cake", "muffin"]):
|
|
return 0.80
|
|
return 0.85 # Default factor for plated meals
|
|
|
|
def estimate_volume(
|
|
self, image_path: str, height_cm: float, food_label: str = ""
|
|
) -> Dict[str, float]:
|
|
"""
|
|
Computes total physical volume in cm³ (mL).
|
|
Volume = Area (cm²) * Height (cm) * Shape Factor
|
|
"""
|
|
area_cm2 = self.calculate_surface_area_cm2(image_path)
|
|
k_shape = self._get_shape_factor(food_label)
|
|
volume_cm3 = area_cm2 * height_cm * k_shape
|
|
|
|
return {
|
|
"surface_area_cm2": round(area_cm2, 2),
|
|
"height_cm": round(height_cm, 2),
|
|
"shape_factor": k_shape,
|
|
"volume_cm3": round(volume_cm3, 2),
|
|
}
|
|
|
|
def reconcile_mass(
|
|
self, edamam_mass_g: float, volume_cm3: float, food_label: str = ""
|
|
) -> Dict[str, Any]:
|
|
"""
|
|
Cross-validates Edamam's visual mass against physical volume using expected density.
|
|
Returns the most physically accurate mass estimate in grams.
|
|
"""
|
|
if volume_cm3 <= 0:
|
|
return {
|
|
"final_mass_g": edamam_mass_g,
|
|
"status": "unvalidated_zero_volume",
|
|
"calculated_density": None,
|
|
}
|
|
|
|
calculated_density = edamam_mass_g / volume_cm3
|
|
label = food_label.lower()
|
|
|
|
# Expected food densities (g/cm³)
|
|
if any(w in label for w in ["bread", "popcorn", "cake"]):
|
|
expected_density = 0.35
|
|
elif any(w in label for w in ["soup", "beverage", "water", "milk"]):
|
|
expected_density = 1.0
|
|
else:
|
|
expected_density = 0.92 # Average cooked meal (water + fats + carbs)
|
|
|
|
# Plausibility bounds (±35% variance around expected density)
|
|
min_density = expected_density * 0.65
|
|
max_density = expected_density * 1.35
|
|
|
|
if min_density <= calculated_density <= max_density:
|
|
# Edamam estimate is physically realistic
|
|
final_mass = edamam_mass_g
|
|
status = "validated_edamam_mass"
|
|
else:
|
|
# Edamam misjudged scale — fallback to Volume * Expected Density
|
|
final_mass = volume_cm3 * expected_density
|
|
status = "reconciled_via_volume_density"
|
|
|
|
return {
|
|
"final_mass_g": round(final_mass, 2),
|
|
"raw_edamam_mass_g": edamam_mass_g,
|
|
"calculated_density_g_cm3": round(calculated_density, 3),
|
|
"expected_density_g_cm3": expected_density,
|
|
"status": status,
|
|
} |