Update app.py

app.py

@@ -1,104 +1,264 @@
 import gradio as gr
+from dotenv import load_dotenv
+from roboflow import Roboflow
+import tempfile
+import os
+import requests
+import cv2
 import numpy as np
-from vision_agent.tools import *
-from vision_agent.tools import countgd_object_detection
-from pillow_heif import register_heif_opener
-from typing import Dict
-
-# Register HEIF opener
-register_heif_opener()
-
-import vision_agent as va
-
-def analyze_mixed_boxes(image) -> Dict:
-    """
-    Analyzes an image containing mixed types of beverages, specifically water bottles and beverage cans.
-    1) Loads the image from the provided path.
-    2) Uses the 'countgd_object_detection' tool with the prompt 'water bottle, beverage can' to detect items.
-    3) Splits detections into a top shelf and bottom shelf by comparing detection center to the image's vertical midpoint.
-    4) Calculates how many water bottles and beverage cans are on each shelf and overall, along with average confidence scores.
-    5) Overlays bounding boxes on the image to visualize detections, then saves the annotated image.
-    6) Returns a dictionary summarizing the distribution of water bottles and beverage cans.
-
-    Parameters:
-        image (PIL.Image): The uploaded image.
-
-    Returns:
-        dict: Summary of the analysis with keys:
-            - total_items (int): total number of detected items
-            - total_water_bottles (int): total count of detected water bottles
-            - total_beverage_cans (int): total count of detected beverage cans
-            - top_shelf (dict): counts of bottles and cans on top shelf
-            - bottom_shelf (dict): counts of bottles and cans on bottom shelf
-            - confidence (dict): average confidence scores for bottles and cans
-    """
-    # Convert the uploaded image to a numpy array
-    image = np.array(image)
-    height, width = image.shape[:2]
-
-    # Detect water bottles and beverage cans
-    detections = countgd_object_detection("water bottle, beverage can", image)
-
-    # Separate detections into top shelf and bottom shelf
-    mid_height = height / 2
-    top_shelf_dets = []
-    bottom_shelf_dets = []
-    for det in detections:
-        cy = ((det["bbox"][1] + det["bbox"][3]) / 2) * height
-        if cy < mid_height:
-            top_shelf_dets.append(det)
+from dds_cloudapi_sdk import Config, Client
+from dds_cloudapi_sdk.tasks.dinox import DinoxTask
+from dds_cloudapi_sdk.tasks.types import DetectionTarget
+from dds_cloudapi_sdk import TextPrompt
+import subprocess
+
+# ========== Konfigurasi ========== 
+load_dotenv()
+
+# Roboflow Config
+rf_api_key = os.getenv("ROBOFLOW_API_KEY")
+workspace = os.getenv("ROBOFLOW_WORKSPACE")
+project_name = os.getenv("ROBOFLOW_PROJECT")
+model_version = int(os.getenv("ROBOFLOW_MODEL_VERSION"))
+
+# DINO-X Config
+DINOX_API_KEY = os.getenv("DINO_X_API_KEY")
+DINOX_PROMPT = "beverage . bottle . cans . mixed box"  # Customize sesuai produk kompetitor : food . drink
+
+# Inisialisasi Model
+rf = Roboflow(api_key=rf_api_key)
+project = rf.workspace(workspace).project(project_name)
+yolo_model = project.version(model_version).model
+
+dinox_config = Config(DINOX_API_KEY)
+dinox_client = Client(dinox_config)
+
+# ========== Fungsi Deteksi Kombinasi ========== 
+def detect_combined(image):
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
+        image.save(temp_file, format="JPEG")
+        temp_path = temp_file.name
+
+    try:
+        # ========== [1] YOLO: Deteksi Produk Nestlé (Per Class) ========== 
+        yolo_pred = yolo_model.predict(temp_path, confidence=50, overlap=80).json()
+
+        # Hitung per class Nestlé
+        nestle_class_count = {}
+        nestle_boxes = []
+        for pred in yolo_pred['predictions']:
+            class_name = pred['class']
+            nestle_class_count[class_name] = nestle_class_count.get(class_name, 0) + 1
+            nestle_boxes.append((pred['x'], pred['y'], pred['width'], pred['height']))
+
+        total_nestle = sum(nestle_class_count.values())
+
+        # ========== [2] DINO-X: Deteksi Kompetitor ========== 
+        image_url = dinox_client.upload_file(temp_path)
+        task = DinoxTask(
+            image_url=image_url,
+            prompts=[TextPrompt(text=DINOX_PROMPT)],
+            bbox_threshold=0.4,
+            targets=[DetectionTarget.BBox]
+        )
+        dinox_client.run_task(task)
+        dinox_pred = task.result.objects
+
+        # Filter & Hitung Kompetitor
+        competitor_class_count = {}
+        competitor_boxes = []
+        for obj in dinox_pred:
+            dinox_box = obj.bbox
+            # Filter objek yang sudah terdeteksi oleh YOLO (Overlap detection)
+            if not is_overlap(dinox_box, nestle_boxes):  # Ignore if overlap with YOLO detections
+                class_name = obj.category.strip().lower()  # Normalisasi nama kelas
+                competitor_class_count[class_name] = competitor_class_count.get(class_name, 0) + 1
+                competitor_boxes.append({
+                    "class": class_name,
+                    "box": dinox_box,
+                    "confidence": obj.score
+                })
+
+        total_competitor = sum(competitor_class_count.values())
+
+        # ========== [3] Format Output ========== 
+        result_text = "Product Nestle\n\n"
+        for class_name, count in nestle_class_count.items():
+            result_text += f"{class_name}: {count}\n"
+        result_text += f"\nTotal Products Nestle: {total_nestle}\n\n"
+
+        #result_text += "Competitor Products\n\n"
+        if competitor_class_count:
+            result_text += f"Total Unclassified Products: {total_competitor}\n"  # Hanya total, tidak per kelas
         else:
-            bottom_shelf_dets.append(det)
+            result_text += "No Unclassified Products detected\n"
 
-    # Count items by label and calculate average confidence
-    water_bottles = [det for det in detections if det["label"] == "water bottle"]
-    beverage_cans = [det for det in detections if det["label"] == "beverage can"]
+        # ========== [4] Visualisasi ========== 
+        img = cv2.imread(temp_path)
 
-    avg_bottle_conf = (sum(det["score"] for det in water_bottles) / len(water_bottles)
-                       if water_bottles else 0)
-    avg_can_conf = (sum(det["score"] for det in beverage_cans) / len(beverage_cans)
-                    if beverage_cans else 0)
+        # Nestlé (Hijau)
+        for pred in yolo_pred['predictions']:
+            x, y, w, h = pred['x'], pred['y'], pred['width'], pred['height']
+            cv2.rectangle(img, (int(x-w/2), int(y-h/2)), (int(x+w/2), int(y+h/2)), (0,255,0), 2)
+            cv2.putText(img, pred['class'], (int(x-w/2), int(y-h/2-10)), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0,255,0), 3)
 
-    top_water_bottles = [det for det in top_shelf_dets if det["label"] == "water bottle"]
-    top_beverage_cans = [det for det in top_shelf_dets if det["label"] == "beverage can"]
-    bottom_water_bottles = [det for det in bottom_shelf_dets if det["label"] == "water bottle"]
-    bottom_beverage_cans = [det for det in bottom_shelf_dets if det["label"] == "beverage can"]
+        # Kompetitor (Merah) dengan nama 'unclassified'
+        for comp in competitor_boxes:
+            x1, y1, x2, y2 = comp['box']
+            
+            # Define a list of target classes to rename
+            unclassified_classes = ["beverage", "cans", "bottle", "mixed box"]
+            
+            # Normalize the class name to be case-insensitive and check if it's in the unclassified list
+            display_name = "unclassified" if any(class_name in comp['class'].lower() for class_name in unclassified_classes) else comp['class']
+            
+            cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
+            cv2.putText(img, f"{display_name} {comp['confidence']:.2f}",
+                        (int(x1), int(y1-10)), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 3)
+            
+        output_path = "/tmp/combined_output.jpg"
+        cv2.imwrite(output_path, img)
 
-    # Overlay bounding boxes and save the annotated image
-    annotated_image = overlay_bounding_boxes(image, detections)
-    
-    # Convert annotated image back to PIL format for Gradio output
-    annotated_image_pil = Image.fromarray(annotated_image)
-    
-    # Return the result
-    result = {
-        "total_items": len(detections),
-        "total_water_bottles": len(water_bottles),
-        "total_beverage_cans": len(beverage_cans),
-        "top_shelf": {
-            "water_bottles": len(top_water_bottles),
-            "beverage_cans": len(top_beverage_cans),
-        },
-        "bottom_shelf": {
-            "water_bottles": len(bottom_water_bottles),
-            "beverage_cans": len(bottom_beverage_cans),
-        },
-        "confidence": {
-            "water_bottles": round(avg_bottle_conf, 2),
-            "beverage_cans": round(avg_can_conf, 2),
-        },
-        "annotated_image": annotated_image_pil  # return annotated image for display
-    }
+        return output_path, result_text
+
+    except Exception as e:
+        return temp_path, f"Error: {str(e)}"
+    finally:
+        os.remove(temp_path)
+
+def is_overlap(box1, boxes2, threshold=0.3):
+    # Fungsi untuk deteksi overlap bounding box
+    x1_min, y1_min, x1_max, y1_max = box1
+    for b2 in boxes2:
+        x2, y2, w2, h2 = b2
+        x2_min = x2 - w2/2
+        x2_max = x2 + w2/2
+        y2_min = y2 - h2/2
+        y2_max = y2 + h2/2
+
+        # Hitung area overlap
+        dx = min(x1_max, x2_max) - max(x1_min, x2_min)
+        dy = min(y1_max, y2_max) - max(y1_min, y2_min)
+        if (dx >= 0) and (dy >= 0):
+            area_overlap = dx * dy
+            area_box1 = (x1_max - x1_min) * (y1_max - y1_min)
+            if area_overlap / area_box1 > threshold:
+                return True
+    return False
+
+# ========== Fungsi untuk Deteksi Video ========== 
+
+def convert_video_to_mp4(input_path, output_path):
+    try:
+        subprocess.run(['ffmpeg', '-i', input_path, '-vcodec', 'libx264', '-acodec', 'aac', output_path], check=True)
+        return output_path
+    except subprocess.CalledProcessError as e:
+        return None, f"Error converting video: {e}"
+
+def detect_objects_in_video(video_path):
+    temp_output_path = "/tmp/output_video.mp4"
+    temp_frames_dir = tempfile.mkdtemp()
+    frame_count = 0
+    previous_detections = {}  # For storing previous frame's object detections
+
+    try:
+        # Convert video to MP4 if necessary
+        if not video_path.endswith(".mp4"):
+            video_path, err = convert_video_to_mp4(video_path, temp_output_path)
+            if not video_path:
+                return None, f"Video conversion error: {err}"
+
+        # Read video and process frames
+        video = cv2.VideoCapture(video_path)
+        frame_rate = int(video.get(cv2.CAP_PROP_FPS))
+        frame_width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        frame_size = (frame_width, frame_height)
+
+        # VideoWriter for output video
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        output_video = cv2.VideoWriter(temp_output_path, fourcc, frame_rate, frame_size)
+
+        while True:
+            ret, frame = video.read()
+            if not ret:
+                break
+
+            # Save frame temporarily for predictions
+            frame_path = os.path.join(temp_frames_dir, f"frame_{frame_count}.jpg")
+            cv2.imwrite(frame_path, frame)
+
+            # Process predictions for the current frame
+            predictions = yolo_model.predict(frame_path, confidence=50, overlap=80).json()
+
+            # Track current frame detections
+            current_detections = {}
+            for prediction in predictions['predictions']:
+                class_name = prediction['class']
+                x, y, w, h = prediction['x'], prediction['y'], prediction['width'], prediction['height']
+                # Generate a unique ID for each detection based on the bounding box
+                object_id = f"{class_name}_{x}_{y}_{w}_{h}"
+
+                # Track each detected object individually
+                if object_id not in current_detections:
+                    current_detections[object_id] = class_name
+
+                # Draw bounding box for detected objects
+                cv2.rectangle(frame, (int(x-w/2), int(y-h/2)), (int(x+w/2), int(y+h/2)), (0,255,0), 2)
+                cv2.putText(frame, class_name, (int(x-w/2), int(y-h/2-10)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 2)
+
+            # Update counts for objects
+            object_counts = {}
+            for detection_id in current_detections.keys():
+                class_name = current_detections[detection_id]
+                object_counts[class_name] = object_counts.get(class_name, 0) + 1
+
+            # Generate display text for counts
+            count_text = ""
+            total_product_count = 0
+            for class_name, count in object_counts.items():
+                count_text += f"{class_name}: {count}\n"
+                total_product_count += count
+            count_text += f"\nTotal Product: {total_product_count}"
+
+            # Overlay the counts text onto the frame
+            y_offset = 20
+            for line in count_text.split("\n"):
+                cv2.putText(frame, line, (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+                y_offset += 30  # Move down for next line
+
+            # Write processed frame to output video
+            output_video.write(frame)
+            frame_count += 1
+
+            # Update previous_detections for the next frame
+            previous_detections = current_detections
+
+        video.release()
+        output_video.release()
+
+        return temp_output_path
+
+    except Exception as e:
+        return None, f"An error occurred: {e}"
+
+# ========== Gradio Interface ========== 
+with gr.Blocks(theme=gr.themes.Base(primary_hue="teal", secondary_hue="teal", neutral_hue="slate")) as iface:
+    gr.Markdown("""<div style="text-align: center;"><h1>NESTLE - STOCK COUNTING</h1></div>""")
     
-    return result
-
-# Gradio Interface
-iface = gr.Interface(
-    fn=analyze_mixed_boxes,
-    inputs=gr.Image(type="pil"),  # allows image upload
-    outputs=[gr.JSON(), gr.Image(type="pil")],  # display result and annotated image
-    title="Beverage Detection Analysis",
-    description="Upload an image containing water bottles and beverage cans, and the tool will analyze the distribution on shelves and display an annotated image.",
-)
-
-iface.launch()
+    with gr.Row():
+        with gr.Column():
+            input_image = gr.Image(type="pil", label="Input Image")
+            detect_image_button = gr.Button("Detect Image")
+            output_image = gr.Image(label="Detect Object")
+            output_text = gr.Textbox(label="Counting Object")
+            detect_image_button.click(fn=detect_combined, inputs=input_image, outputs=[output_image, output_text])
+
+        with gr.Column():
+            input_video = gr.Video(label="Input Video")
+            detect_video_button = gr.Button("Detect Video")
+            output_video = gr.Video(label="Output Video")
+            detect_video_button.click(fn=detect_objects_in_video, inputs=input_video, outputs=[output_video])
+
+iface.launch()