Update app.py

app.py

@@ -17,21 +17,24 @@ workspace = os.getenv("ROBOFLOW_WORKSPACE")
 project_name = os.getenv("ROBOFLOW_PROJECT")
 model_version = int(os.getenv("ROBOFLOW_MODEL_VERSION"))
 
-# CountGD Config (Replace DINO-X)
-# Set your CountGD API key in your .env file (e.g., COUNTGD_API_KEY=YourEncodedAPIKey)
+# CountGD Config (menggantikan DINO-X)
+# Pastikan API key CountGD telah di-set di .env dengan key COUNTGD_API_KEY
 COUNTGD_API_KEY = os.getenv("COUNTGD_API_KEY")
 
-# Inisialisasi YOLO Model from Roboflow
+# Inisialisasi YOLO Model dari Roboflow
 rf = Roboflow(api_key=rf_api_key)
 project = rf.workspace(workspace).project(project_name)
 yolo_model = project.version(model_version).model
 
-# ========== Function to Check Overlap ==========
+# List prompt untuk CountGD (misal: cans, bottle, mixed box)
+COUNTGD_PROMPTS = ["cans", "bottle", "mixed box"]
+
+# ========== Fungsi untuk Mengecek 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.
+    Mengecek apakah box1 (format: (x_min, y_min, x_max, y_max)) overlap dengan salah satu box di boxes2.
+    boxes2 adalah list bounding box dari YOLO dengan format (x_center, y_center, width, height).
+    Mengembalikan True jika rasio overlap melebihi threshold.
     """
     x1_min, y1_min, x1_max, y1_max = box1
     for b2 in boxes2:
@@ -41,7 +44,6 @@ def is_overlap(box1, boxes2, threshold=0.3):
         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:
@@ -51,44 +53,45 @@ def is_overlap(box1, boxes2, threshold=0.3):
                 return True
     return False
 
-# ========== Combined Object Detection Function ==========
+# ========== 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:
-        # ===== YOLO Detection (Nestlé products) =====
+        # ===== YOLO Detection (Produk Nestlé) =====
         yolo_pred = yolo_model.predict(temp_path, confidence=50, overlap=80).json()
         nestle_class_count = {}
-        nestle_boxes = []  # List to hold YOLO bounding boxes (format: x_center, y_center, width, height)
+        nestle_boxes = []  # Menyimpan bounding box YOLO dengan 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 (Produk Kompetitor) =====
         url = "https://api.landing.ai/v1/tools/text-to-object-detection"
         files = {"image": open(temp_path, "rb")}
-        data = {"prompts": ["mixed box"], "model": "countgd"}
+        # Menggunakan lebih dari satu prompt
+        data = {"prompts": COUNTGD_PROMPTS, "model": "countgd"}
         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 = []  # List to hold CountGD bounding boxes (format: x_min, y_min, x_max, y_max)
+        competitor_boxes = []  # Menyimpan bounding box CountGD dengan format (x_min, y_min, x_max, y_max)
         if 'data' in result:
+            # Asumsi API mengembalikan list deteksi pada data[0]
             for obj in result['data'][0]:
                 if 'bounding_box' in obj:
-                    # 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)
+                    # Mengambil label jika tersedia, default 'unclassified'
+                    label = obj.get('label', 'unclassified')
+                    # Hanya tambahkan deteksi jika tidak overlap dengan deteksi YOLO
+                    if not is_overlap((x1, y1, x2, y2), nestle_boxes, threshold=0.3):
+                        competitor_class_count[label] = competitor_class_count.get(label, 0) + 1
+                        competitor_boxes.append((x1, y1, x2, y2))
         total_competitor = sum(competitor_class_count.values())
         
         # ===== Format Output Text =====
@@ -97,13 +100,16 @@ def detect_combined(image):
             result_text += f"{class_name}: {count}\n"
         result_text += f"\nTotal Products Nestlé: {total_nestle}\n\n"
         if total_competitor:
-            result_text += f"Total Unclassified Products: {total_competitor}\n"
+            result_text += "Produk Kompetitor (CountGD) :\n"
+            for label, count in competitor_class_count.items():
+                result_text += f"{label}: {count}\n"
+            result_text += f"\nTotal Produk Kompetitor: {total_competitor}\n"
         else:
             result_text += "No Unclassified Products detected\n"
         
-        # ===== Visualization =====
+        # ===== Visualisasi =====
         img = cv2.imread(temp_path)
-        # Draw YOLO boxes in green
+        # Gambar bounding box YOLO (hijau)
         for pred in yolo_pred['predictions']:
             x, y, w, h = pred['x'], pred['y'], pred['width'], pred['height']
             pt1 = (int(x - w/2), int(y - h/2))
@@ -111,10 +117,11 @@ def detect_combined(image):
             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
+        # Gambar bounding box CountGD (merah)
         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)
+            # Tampilkan label hasil CountGD
             cv2.putText(img, "unclassified", (int(x1), int(y1)-10),
                         cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0,0,255), 3)
         
@@ -129,7 +136,7 @@ def detect_combined(image):
         if os.path.exists(temp_path):
             os.remove(temp_path)
 
-# ========== Video Detection Functions ==========
+# ========== 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)
@@ -141,23 +148,21 @@ 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 detections
+    previous_detections = {}  # Untuk menyimpan deteksi frame sebelumnya
 
     try:
-        # Convert video to MP4 if necessary
+        # Konversi video ke MP4 jika perlu
         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}"
 
-        # 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)
 
-        # Setup VideoWriter for output
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         output_video = cv2.VideoWriter(temp_output_path, fourcc, frame_rate, frame_size)
 
@@ -166,14 +171,11 @@ def detect_objects_in_video(video_path):
             if not ret:
                 break
 
-            # Save frame for YOLO detection
             frame_path = os.path.join(temp_frames_dir, f"frame_{frame_count}.jpg")
             cv2.imwrite(frame_path, frame)
 
-            # YOLO detection on the frame
             predictions = yolo_model.predict(frame_path, confidence=50, overlap=80).json()
 
-            # Draw YOLO detections on the frame
             current_detections = {}
             for prediction in predictions['predictions']:
                 class_name = prediction['class']
@@ -187,7 +189,6 @@ def detect_objects_in_video(video_path):
                 cv2.putText(frame, class_name, (pt1[0], pt1[1]-10),
                             cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 2)
 
-            # Count objects and overlay text
             object_counts = {}
             for detection_id in current_detections:
                 cls = current_detections[detection_id]