Update app.py

app.py

@@ -26,7 +26,7 @@ rf = Roboflow(api_key=rf_api_key)
 project = rf.workspace(workspace).project(project_name)
 yolo_model = project.version(model_version).model
 
-# ========== Fungsi untuk Mengecek Overlap ==========
+# ========== Fungsi untuk Mengecek Overlap antara YOLO dan CountGD ==========
 def is_overlap(box1, boxes2, threshold=0.3):
     """
     Mengecek apakah box1 (format: (x_min, y_min, x_max, y_max)) overlap dengan salah satu box di boxes2.
@@ -50,67 +50,87 @@ def is_overlap(box1, boxes2, threshold=0.3):
                 return True
     return False
 
+# ========== Fungsi untuk Menghitung IoU antar dua bounding box ==========
+def iou(boxA, boxB):
+    """
+    Menghitung Intersection over Union (IoU) antara dua bounding box.
+    Masing-masing box dalam format (x_min, y_min, x_max, y_max).
+    """
+    xA = max(boxA[0], boxB[0])
+    yA = max(boxA[1], boxB[1])
+    xB = min(boxA[2], boxB[2])
+    yB = min(boxA[3], boxB[3])
+    interArea = max(0, xB - xA) * max(0, yB - yA)
+    boxAArea = (boxA[2] - boxA[0]) * (boxA[3] - boxA[1])
+    boxBArea = (boxB[2] - boxB[0]) * (boxB[3] - boxB[1])
+    iou_val = interArea / float(boxAArea + boxBArea - interArea) if (boxAArea + boxBArea - interArea) > 0 else 0
+    return iou_val
+
 # ========== Fungsi Deteksi Kombinasi ==========
 def detect_combined(image):
-    # Simpan image ke file sementara
     with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
         image.save(temp_file, format="JPEG")
         temp_path = temp_file.name
-
+    
     try:
         # ===== YOLO Detection (Produk Nestlé) =====
         yolo_pred = yolo_model.predict(temp_path, confidence=50, overlap=80).json()
         nestle_class_count = {}
-        nestle_boxes = []  # Menyimpan bounding box YOLO (format: x_center, y_center, width, height)
+        nestle_boxes = []  # List untuk menyimpan bounding box YOLO (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 (Produk Kompetitor) =====
         url = "https://api.landing.ai/v1/tools/text-to-object-detection"
         competitor_class_count = {}
-        competitor_boxes = []  # Menyimpan bounding box CountGD (format: x_min, y_min, x_max, y_max)
+        competitor_boxes = []  # List untuk menyimpan bounding box CountGD (format: x_min, y_min, x_max, y_max)
         # Daftar prompt yang akan digunakan
         COUNTGD_PROMPTS = ["cans", "bottle", "mixed box"]
         headers = {"Authorization": f"Basic {COUNTGD_API_KEY}"}
         
         for prompt in COUNTGD_PROMPTS:
-            # Untuk setiap prompt, buka file gambar dan kirim request
             with open(temp_path, "rb") as f:
                 files = {"image": f}
                 data = {"prompts": [prompt], "model": "countgd"}
                 response = requests.post(url, files=files, data=data, headers=headers)
             result = response.json()
-            # Cek apakah API mengembalikan data
             if 'data' in result and result['data']:
                 detections = result['data'][0]
                 for obj in detections:
                     if 'bounding_box' in obj:
                         x1, y1, x2, y2 = obj['bounding_box']
                         countgd_box = (x1, y1, x2, y2)
-                        # Hanya tambahkan deteksi jika tidak overlap signifikan dengan YOLO
+                        # Hanya tambahkan deteksi jika tidak overlap dengan deteksi YOLO
                         if not is_overlap(countgd_box, nestle_boxes, threshold=0.3):
-                            # Gunakan label dari respons jika ada, jika tidak gunakan prompt sebagai default
-                            label = obj.get('label', prompt)
-                            competitor_class_count[label] = competitor_class_count.get(label, 0) + 1
-                            competitor_boxes.append(countgd_box)
+                            # Cek duplikasi antar deteksi CountGD menggunakan IoU
+                            duplicate = False
+                            for existing_box in competitor_boxes:
+                                if iou(countgd_box, existing_box) > 0.5:
+                                    duplicate = True
+                                    break
+                            if not duplicate:
+                                # Gunakan label dari respons jika ada, jika tidak gunakan prompt sebagai default
+                                label = obj.get('label', prompt)
+                                competitor_class_count[label] = competitor_class_count.get(label, 0) + 1
+                                competitor_boxes.append(countgd_box)
         total_competitor = sum(competitor_class_count.values())
-
+        
         # ===== 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"
         if total_competitor:
-            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"
+            #result_text += "Produk Kompetitor (CountGD):\n"
+            #for label, count in competitor_class_count.items():
+            #    result_text += f"{label}: {count}\n"
+            result_text += f"\nTotal Unclassified Products: {total_competitor}\n"
         else:
             result_text += "No Unclassified Products detected\n"
-
+        
         # ===== Visualisasi =====
         img = cv2.imread(temp_path)
         # Gambar bounding box YOLO (hijau)
@@ -127,14 +147,14 @@ def detect_combined(image):
             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)
         return output_path, result_text
-
+    
     except Exception as e:
         return temp_path, f"Error: {str(e)}"
-
+    
     finally:
         if os.path.exists(temp_path):
             os.remove(temp_path)
@@ -160,14 +180,12 @@ def detect_objects_in_video(video_path):
             if not video_path:
                 return None, f"Video conversion error: {err}"
 
-        # Buka video untuk diproses
         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 untuk output
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         output_video = cv2.VideoWriter(temp_output_path, fourcc, frame_rate, frame_size)
 
@@ -176,14 +194,11 @@ def detect_objects_in_video(video_path):
             if not ret:
                 break
 
-            # Simpan frame untuk deteksi YOLO
             frame_path = os.path.join(temp_frames_dir, f"frame_{frame_count}.jpg")
             cv2.imwrite(frame_path, frame)
 
-            # YOLO detection pada frame
             predictions = yolo_model.predict(frame_path, confidence=50, overlap=80).json()
 
-            # Gambar deteksi YOLO pada frame
             current_detections = {}
             for prediction in predictions['predictions']:
                 class_name = prediction['class']
@@ -197,7 +212,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)
 
-            # Hitung dan tampilkan jumlah deteksi pada frame
             object_counts = {}
             for detection_id in current_detections:
                 cls = current_detections[detection_id]