Update app.py

app.py

@@ -6,13 +6,9 @@ import os
 import requests
 import cv2
 import numpy as np
-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 Environment Variables ==========
 load_dotenv()
 
 # Roboflow Config
@@ -21,71 +17,106 @@ 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
+# CountGD Config (Replace DINO-X)
+# Set your CountGD API key in your .env file (e.g., COUNTGD_API_KEY=YourEncodedAPIKey)
+COUNTGD_API_KEY = os.getenv("COUNTGD_API_KEY")
 
-# Inisialisasi Model
+# Inisialisasi YOLO Model from Roboflow
 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)
+# ========== Function to Check Overlap ==========
+def is_overlap(box1, boxes2, threshold=0.3):
+    """
+    Checks if box1 (format: (x_min, y_min, x_max, y_max)) overlaps with any boxes in boxes2.
+    boxes2 is a list of YOLO bounding boxes in the format (x_center, y_center, width, height).
+    Returns True if the overlap ratio of box1 is greater than the threshold.
+    """
+    x1_min, y1_min, x1_max, y1_max = box1
+    for b2 in boxes2:
+        x_center, y_center, w2, h2 = b2
+        x2_min = x_center - w2 / 2
+        x2_max = x_center + w2 / 2
+        y2_min = y_center - h2 / 2
+        y2_max = y_center + h2 / 2
+
+        # Calculate overlap area
+        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_box1 > 0 and (area_overlap / area_box1) > threshold:
+                return True
+    return False
 
-# ========== Fungsi Deteksi Kombinasi ========== 
+# ========== Combined Object Detection Function ==========
 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:
-        # YOLO Detection (Nestlé products)
+        # ===== YOLO Detection (Nestlé products) =====
         yolo_pred = yolo_model.predict(temp_path, confidence=50, overlap=80).json()
         nestle_class_count = {}
-        nestle_boxes = []
+        nestle_boxes = []  # List to hold YOLO bounding boxes (format: x_center, y_center, width, height)
         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())
         
-        # CountGD Detection (Competitor products)
+        # ===== CountGD Detection (Competitor products) =====
         url = "https://api.landing.ai/v1/tools/text-to-object-detection"
         files = {"image": open(temp_path, "rb")}
         data = {"prompts": ["mixed box"], "model": "countgd"}
-        headers = {"Authorization": "Basic YOUR_API_KEY"}  # Replace with actual API key
+        headers = {"Authorization": f"Basic {COUNTGD_API_KEY}"}
         response = requests.post(url, files=files, data=data, headers=headers)
         result = response.json()
         
         competitor_class_count = {}
-        competitor_boxes = []
+        competitor_boxes = []  # List to hold CountGD bounding boxes (format: x_min, y_min, x_max, y_max)
         if 'data' in result:
             for obj in result['data'][0]:
                 if 'bounding_box' in obj:
-                    x, y, x2, y2 = obj['bounding_box']
-                    class_name = "unclassified"  # CountGD does not classify, so use generic label
-                    competitor_class_count[class_name] = competitor_class_count.get(class_name, 0) + 1
-                    competitor_boxes.append((x, y, x2, y2))
+                    # CountGD returns bounding_box as [x_min, y_min, x_max, y_max]
+                    x1, y1, x2, y2 = obj['bounding_box']
+                    countgd_box = (x1, y1, x2, y2)
+                    # Only add CountGD detection if it does NOT significantly overlap with any YOLO detection
+                    if not is_overlap(countgd_box, nestle_boxes, threshold=0.3):
+                        class_name = "unclassified"  # Generic label for competitor objects
+                        competitor_class_count[class_name] = competitor_class_count.get(class_name, 0) + 1
+                        competitor_boxes.append(countgd_box)
         total_competitor = sum(competitor_class_count.values())
         
-        # Format Output
+        # ===== Format Output Text =====
         result_text = "Product Nestlé\n\n"
         for class_name, count in nestle_class_count.items():
             result_text += f"{class_name}: {count}\n"
         result_text += f"\nTotal Products Nestlé: {total_nestle}\n\n"
-        result_text += f"Total Unclassified Products: {total_competitor}\n" if total_competitor else "No Unclassified Products detected\n"
+        if total_competitor:
+            result_text += f"Total Unclassified Products: {total_competitor}\n"
+        else:
+            result_text += "No Unclassified Products detected\n"
         
-        # Visualization
+        # ===== Visualization =====
         img = cv2.imread(temp_path)
+        # Draw YOLO boxes in green
         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)
-        
-        for x1, y1, x2, y2 in competitor_boxes:
-            cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (0,0,255), 2)
-            cv2.putText(img, "unclassified", (int(x1), int(y1-10)), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0,0,255), 3)
+            pt1 = (int(x - w/2), int(y - h/2))
+            pt2 = (int(x + w/2), int(y + h/2))
+            cv2.rectangle(img, pt1, pt2, (0, 255, 0), 2)
+            cv2.putText(img, pred['class'], (pt1[0], pt1[1]-10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0,255,0), 3)
+        # Draw CountGD boxes in red
+        for box in competitor_boxes:
+            x1, y1, x2, y2 = box
+            cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
+            cv2.putText(img, "unclassified", (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)
@@ -95,30 +126,10 @@ def detect_combined(image):
         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 ========== 
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
 
+# ========== Video Detection Functions ==========
 def convert_video_to_mp4(input_path, output_path):
     try:
         subprocess.run(['ffmpeg', '-i', input_path, '-vcodec', 'libx264', '-acodec', 'aac', output_path], check=True)
@@ -130,7 +141,7 @@ 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
+    previous_detections = {}  # For storing previous frame's detections
 
     try:
         # Convert video to MP4 if necessary
@@ -139,14 +150,14 @@ def detect_objects_in_video(video_path):
             if not video_path:
                 return None, f"Video conversion error: {err}"
 
-        # Read video and process frames
+        # Open video for processing
         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
+        # Setup VideoWriter for output
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         output_video = cv2.VideoWriter(temp_output_path, fourcc, frame_rate, frame_size)
 
@@ -155,54 +166,46 @@ def detect_objects_in_video(video_path):
             if not ret:
                 break
 
-            # Save frame temporarily for predictions
+            # Save frame for YOLO detection
             frame_path = os.path.join(temp_frames_dir, f"frame_{frame_count}.jpg")
             cv2.imwrite(frame_path, frame)
 
-            # Process predictions for the current frame
+            # YOLO detection on the frame
             predictions = yolo_model.predict(frame_path, confidence=50, overlap=80).json()
 
-            # Track current frame detections
+            # Draw YOLO detections on the frame
             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
+                pt1 = (int(x - w/2), int(y - h/2))
+                pt2 = (int(x + w/2), int(y + h/2))
+                cv2.rectangle(frame, pt1, pt2, (0,255,0), 2)
+                cv2.putText(frame, class_name, (pt1[0], pt1[1]-10),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 2)
 
-                # 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
+            # Count objects and overlay text
             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
+            for detection_id in current_detections:
+                cls = current_detections[detection_id]
+                object_counts[cls] = object_counts.get(cls, 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"
+            for cls, count in object_counts.items():
+                count_text += f"{cls}: {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
+                cv2.putText(frame, line, (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255,255,255), 2)
+                y_offset += 30
 
-            # 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()
@@ -213,7 +216,7 @@ def detect_objects_in_video(video_path):
     except Exception as e:
         return None, f"An error occurred: {e}"
 
-# ========== Gradio Interface ========== 
+# ========== 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>""")
     
@@ -224,11 +227,10 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue="teal", secondary_hue="teal", ne
             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()
+iface.launch()