Update app.py

app.py

@@ -1,14 +1,14 @@
-import gradio as gr
-from dotenv import load_dotenv
-from roboflow import Roboflow
-import tempfile
 import os
+import numpy as np
+import tempfile
 import requests
 import cv2
-import numpy as np
+import gradio as gr
+from dotenv import load_dotenv
+from roboflow import Roboflow
 import subprocess
 
-# ========== Konfigurasi ==========
+# ========== Konfigurasi ========== 
 load_dotenv()
 
 # Roboflow Config
@@ -17,97 +17,96 @@ workspace = os.getenv("ROBOFLOW_WORKSPACE")
 project_name = os.getenv("ROBOFLOW_PROJECT")
 model_version = int(os.getenv("ROBOFLOW_MODEL_VERSION"))
 
-# CountGD Config
-COUNTGD_PROMPT = "beverage . bottle . cans . mixed box"  # Sesuaikan prompt sesuai kebutuhan
-COUNTGD_API_KEY = os.getenv("COUNTGD_API_KEY")       # API key CountGD
+# countgd Model Configuration
+COUNTGD_API_KEY = os.getenv("COUNTGD_API_KEY")
+COUNTGD_MODEL_URL = "https://api.landing.ai/v1/tools/countgd-object-detection"  # Replace with the correct API endpoint
 
-# Inisialisasi Model YOLO dari Roboflow
+# Inisialisasi Model
 rf = Roboflow(api_key=rf_api_key)
 project = rf.workspace(workspace).project(project_name)
 yolo_model = project.version(model_version).model
 
-# ========== Fungsi Deteksi Kombinasi ==========
+# ========== Fungsi Deteksi Kombinasi ========== 
 def detect_combined(image):
-    # Simpan gambar ke file temporer
     with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
         image.save(temp_file, format="JPEG")
         temp_path = temp_file.name
 
     try:
-        # ========== [1] Deteksi Produk Nestlé dengan YOLO ==========
+        # ========== [1] YOLO: Deteksi Produk Nestlé (Per Class) ========== 
         yolo_pred = yolo_model.predict(temp_path, confidence=50, overlap=80).json()
 
-        # Hitung per kelas dan simpan bounding box (format: (x_center, y_center, width, height))
+        # Hitung per class Nestlé
         nestle_class_count = {}
         nestle_boxes = []
-        for pred in yolo_pred.get('predictions', []):
+        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] Deteksi Kompetitor dengan CountGD ==========
-        countgd_url = "https://api.landing.ai/v1/tools/text-to-object-detection"
-        with open(temp_path, "rb") as image_file:
-            files = {"image": image_file}
-            data = {
-                "prompts": [COUNTGD_PROMPT],
-                "model": "countgd"
-            }
-            headers = {
-                "Authorization": f"Basic {COUNTGD_API_KEY}",
-                "Content-Type": "multipart/form-data"
-            }
-            response = requests.post(countgd_url, files=files, data=data, headers=headers)
-        countgd_pred = response.json()
+        # ========== [2] countgd: Deteksi Produk dengan countgd Model ========== 
+        # Make a request to the countgd model API (adjust parameters accordingly)
+        with open(temp_path, 'rb') as img_file:
+            response = requests.post(
+                COUNTGD_MODEL_URL,
+                headers={"Authorization": f"Bearer {COUNTGD_API_KEY}"},
+                files={"image": img_file},
+                data={"prompts": ["water bottle", "beverage can"]}
+            )
+
+        # Handle the response from the countgd model
+        if response.status_code == 200:
+            countgd_pred = response.json()['detections']
+        else:
+            return temp_path, f"Error calling countgd API: {response.text}"
 
+        # Filter & Hitung Kompetitor
         competitor_class_count = {}
         competitor_boxes = []
-        # Asumsikan respons JSON mengandung key "predictions" berupa daftar objek
-        for obj in countgd_pred.get("predictions", []):
-            countgd_box = obj.get("bbox")  # Format: [x1, y1, x2, y2]
-            # Lakukan filter untuk menghindari duplikasi dengan deteksi YOLO
-            if not is_overlap(countgd_box, nestle_boxes):
-                class_name = obj.get("class", "").strip().lower()
+        for obj in countgd_pred:
+            # Filter and process the detections
+            class_name = obj['label']
+            if class_name.lower() in ['water bottle', 'beverage can']:  # Modify this as needed
                 competitor_class_count[class_name] = competitor_class_count.get(class_name, 0) + 1
                 competitor_boxes.append({
                     "class": class_name,
-                    "box": countgd_box,
-                    "confidence": obj.get("score", 0)
+                    "box": obj['bbox'],
+                    "confidence": obj['score']
                 })
 
         total_competitor = sum(competitor_class_count.values())
 
-        # ========== [3] Format Output ==========
-        result_text = "Product Nestlé\n\n"
+        # ========== [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 Nestlé: {total_nestle}\n\n"
+        result_text += f"\nTotal Products Nestle: {total_nestle}\n\n"
+
+        # Unclassified Products (from countgd model)
         if competitor_class_count:
             result_text += f"Total Unclassified Products: {total_competitor}\n"
         else:
             result_text += "No Unclassified Products detected\n"
 
-        # ========== [4] Visualisasi ==========
+        # ========== [4] Visualisasi ========== 
         img = cv2.imread(temp_path)
-        # Tandai bounding box untuk produk Nestlé (warna hijau)
-        for pred in yolo_pred.get('predictions', []):
+
+        # 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)
+            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, 0.55, (0,255,0), 2)
 
-        # Tandai bounding box untuk kompetitor (warna merah)
+        # Kompetitor (Merah) with countgd detections
         for comp in competitor_boxes:
             x1, y1, x2, y2 = comp['box']
-            # Ubah nama kelas menjadi 'unclassified' jika sesuai dengan daftar target
-            unclassified_classes = ["beverage", "cans", "bottle", "mixed box"]
-            display_name = "unclassified" if any(uc in comp['class'] for uc 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)
-
+            cv2.putText(img, f"{comp['class']} {comp['confidence']:.2f}",
+                        (int(x1), int(y1-10)), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (0, 0, 255), 2)
+            
         output_path = "/tmp/combined_output.jpg"
         cv2.imwrite(output_path, img)
 
@@ -118,29 +117,8 @@ def detect_combined(image):
     finally:
         os.remove(temp_path)
 
-def is_overlap(box1, boxes2, threshold=0.3):
-    """
-    Fungsi untuk mendeteksi overlap antara bounding box dari CountGD (format: [x1, y1, x2, y2])
-    dan bounding box YOLO (format: (x_center, y_center, width, height)).
-    """
-    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
-
-        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 ==========
+# ========== 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)
@@ -152,20 +130,22 @@ def detect_objects_in_video(video_path):
     temp_output_path = "/tmp/output_video.mp4"
     temp_frames_dir = tempfile.mkdtemp()
     frame_count = 0
-    previous_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)
 
@@ -174,54 +154,47 @@ def detect_objects_in_video(video_path):
             if not ret:
                 break
 
+            # Process predictions for the current frame using countgd model (same as in image detection)
             frame_path = os.path.join(temp_frames_dir, f"frame_{frame_count}.jpg")
             cv2.imwrite(frame_path, frame)
 
-            predictions = yolo_model.predict(frame_path, confidence=50, overlap=80).json()
-            current_detections = {}
-            for prediction in predictions.get('predictions', []):
-                class_name = prediction['class']
-                x, y, w, h = prediction['x'], prediction['y'], prediction['width'], prediction['height']
-                object_id = f"{class_name}_{x}_{y}_{w}_{h}"
-                if object_id not in current_detections:
-                    current_detections[object_id] = class_name
-
-                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)
-
-            object_counts = {}
-            for detection_id, class_name in current_detections.items():
-                object_counts[class_name] = object_counts.get(class_name, 0) + 1
-
-            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}"
-
-            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
-
+            # Get predictions from countgd (adjust accordingly for video frames)
+            response = requests.post(
+                COUNTGD_MODEL_URL,
+                headers={"Authorization": f"Bearer {COUNTGD_API_KEY}"},
+                files={"image": open(frame_path, 'rb')},
+                data={"prompts": ["water bottle", "beverage can"]}
+            )
+
+            # Process the response (similarly to what was done for image detection)
+            if response.status_code == 200:
+                countgd_pred = response.json()['detections']
+            else:
+                continue
+
+            # Drawing detections on frames
+            for obj in countgd_pred:
+                x1, y1, x2, y2 = obj['bbox']
+                cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 255), 2)
+                cv2.putText(frame, f"{obj['label']} {obj['score']:.2f}", 
+                            (int(x1), int(y1-10)), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (0, 0, 255), 2)
+
+            # Write processed frame to output video
             output_video.write(frame)
             frame_count += 1
-            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 ==========
+# ========== 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>""")
+    
     with gr.Row():
         with gr.Column():
             input_image = gr.Image(type="pil", label="Input Image")
@@ -229,10 +202,11 @@ 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()