Update app.py

app.py

@@ -3,9 +3,10 @@ from dotenv import load_dotenv
 from roboflow import Roboflow
 import tempfile
 import os
+import requests
 import cv2
 import numpy as np
-import vision_agent.tools as T
+import subprocess
 
 # ========== Konfigurasi ==========
 load_dotenv()
@@ -17,87 +18,95 @@ project_name = os.getenv("ROBOFLOW_PROJECT")
 model_version = int(os.getenv("ROBOFLOW_MODEL_VERSION"))
 
 # CountGD Config
-COUNTGD_PROMPT = "cans . bottle"  # Customize sesuai kebutuhan
+COUNTGD_PROMPT = "beverage . bottle . cans . mixed box"  # Sesuaikan prompt sesuai kebutuhan
+COUNTGD_API_KEY = os.getenv("COUNTGD_API_KEY")       # API key CountGD
 
-# Inisialisasi Model
+# Inisialisasi Model YOLO dari Roboflow
 rf = Roboflow(api_key=rf_api_key)
 project = rf.workspace(workspace).project(project_name)
 yolo_model = project.version(model_version).model
 
 # ========== 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] YOLO: Deteksi Produk Nestlé ==========
-        yolo_pred = yolo_model.predict(temp_path, confidence=60, overlap=80).json()
-        
-        # Hitung per class Nestlé
+        # ========== [1] Deteksi Produk Nestlé dengan YOLO ==========
+        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))
         nestle_class_count = {}
         nestle_boxes = []
-        for pred in yolo_pred['predictions']:
+        for pred in yolo_pred.get('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] CountGD: Deteksi Kompetitor ==========
-        img = cv2.imread(temp_path)
-        prompts = [p.strip() for p in COUNTGD_PROMPT.split('.') if p.strip()]
-        
-        competitor_detections = []
-        for prompt in prompts:
-            dets = T.countgd_object_detection(prompt, img)
-            competitor_detections.extend(dets)
-
-        # Filter & Hitung Kompetitor
+        # ========== [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()
+
         competitor_class_count = {}
         competitor_boxes = []
-        for det in competitor_detections:
-            bbox = det['bbox']
-            class_name = det['class_name']
-            
-            if not is_overlap(bbox, nestle_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()
                 competitor_class_count[class_name] = competitor_class_count.get(class_name, 0) + 1
                 competitor_boxes.append({
                     "class": class_name,
-                    "box": bbox,
-                    "confidence": det['score']
+                    "box": countgd_box,
+                    "confidence": obj.get("score", 0)
                 })
 
         total_competitor = sum(competitor_class_count.values())
 
         # ========== [3] Format Output ==========
-        result_text = "Product Nestle\n\n"
+        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 Product Nestle: {total_nestle}\n\n"
-
-        result_text += "Competitor Products\n\n"
+        result_text += f"\nTotal Products Nestlé: {total_nestle}\n\n"
         if competitor_class_count:
-            for class_name, count in competitor_class_count.items():
-                result_text += f"{class_name}: {count}\n"
+            result_text += f"Total Unclassified Products: {total_competitor}\n"
         else:
-            result_text += "No competitors detected\n"
-        result_text += f"\nTotal Competitor: {total_competitor}"
+            result_text += "No Unclassified Products detected\n"
 
         # ========== [4] Visualisasi ==========
-        # Gambar bounding box Nestlé (Hijau)
-        for pred in yolo_pred['predictions']:
+        img = cv2.imread(temp_path)
+        # Tandai bounding box untuk produk Nestlé (warna hijau)
+        for pred in yolo_pred.get('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, 0.5, (0,255,0), 2)
+            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)
 
-        # Gambar bounding box Kompetitor (Merah)
+        # Tandai bounding box untuk kompetitor (warna merah)
         for comp in competitor_boxes:
-            x1, y1, x2, y2 = map(int, comp['box'])
-            cv2.rectangle(img, (x1, y1), (x2, y2), (0,0,255), 2)
-            cv2.putText(img, f"{comp['class']} {comp['confidence']:.2f}", 
-                       (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,255), 2)
+            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)
 
         output_path = "/tmp/combined_output.jpg"
         cv2.imwrite(output_path, img)
@@ -109,151 +118,121 @@ def detect_combined(image):
     finally:
         os.remove(temp_path)
 
-def is_overlap(countgd_bbox, yolo_boxes, iou_threshold=0.3):
+def is_overlap(box1, boxes2, threshold=0.3):
     """
-    Deteksi overlap menggunakan Intersection over Union (IoU)
-    Format bbox:
-    - CountGD: [x1, y1, x2, y2]
-    - YOLO: (x_center, y_center, width, height)
+    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)).
     """
-    # Convert YOLO boxes to [x1,y1,x2,y2]
-    yolo_boxes_converted = []
-    for yb in yolo_boxes:
-        x_center, y_center, width, height = yb
-        x1 = x_center - width/2
-        y1 = y_center - height/2
-        x2 = x_center + width/2
-        y2 = y_center + height/2
-        yolo_boxes_converted.append((x1, y1, x2, y2))
-    
-    # Convert CountGD bbox to [x1,y1,x2,y2]
-    countgd_x1, countgd_y1, countgd_x2, countgd_y2 = countgd_bbox
-    
-    # Hitung IoU dengan semua YOLO boxes
-    for yolo_bbox in yolo_boxes_converted:
-        yolo_x1, yolo_y1, yolo_x2, yolo_y2 = yolo_bbox
-        
-        # Hitung area intersection
-        x_left = max(countgd_x1, yolo_x1)
-        y_top = max(countgd_y1, yolo_y1)
-        x_right = min(countgd_x2, yolo_x2)
-        y_bottom = min(countgd_y2, yolo_y2)
-        
-        if x_right < x_left or y_bottom < y_top:
-            continue
-            
-        intersection_area = (x_right - x_left) * (y_bottom - y_top)
-        
-        # Hitung area union
-        countgd_area = (countgd_x2 - countgd_x1) * (countgd_y2 - countgd_y1)
-        yolo_area = (yolo_x2 - yolo_x1) * (yolo_y2 - yolo_y1)
-        union_area = countgd_area + yolo_area - intersection_area
-        
-        iou = intersection_area / union_area if union_area > 0 else 0
-        
-        if iou > iou_threshold:
-            return True
+    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 ==========
+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 = "/tmp/output_video.mp4"
-    temp_dir = tempfile.mkdtemp()
-    
+    temp_output_path = "/tmp/output_video.mp4"
+    temp_frames_dir = tempfile.mkdtemp()
+    frame_count = 0
+    previous_detections = {}
+
     try:
-        cap = cv2.VideoCapture(video_path)
-        fps = int(cap.get(cv2.CAP_PROP_FPS))
-        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        
+        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}"
+
+        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)
+
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(temp_output, fourcc, fps, (width, height))
-        
-        total_counts = {}
-        frame_idx = 0
-        
-        while cap.isOpened():
-            ret, frame = cap.read()
+        output_video = cv2.VideoWriter(temp_output_path, fourcc, frame_rate, frame_size)
+
+        while True:
+            ret, frame = video.read()
             if not ret:
                 break
-                
-            frame_path = os.path.join(temp_dir, f"frame_{frame_idx}.jpg")
+
+            frame_path = os.path.join(temp_frames_dir, f"frame_{frame_count}.jpg")
             cv2.imwrite(frame_path, frame)
-            
-            # Deteksi dengan YOLO
-            predictions = yolo_model.predict(frame_path, confidence=60, overlap=80).json()
-            
-            # Update counts dan gambar bounding box
-            class_count = {}
-            for pred in predictions['predictions']:
-                class_name = pred['class']
-                class_count[class_name] = class_count.get(class_name, 0) + 1
-                total_counts[class_name] = total_counts.get(class_name, 0) + 1
-                
-                x, y, w, h = pred['x'], pred['y'], pred['width'], pred['height']
-                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)
-            
-            # Tampilkan counter
-            y_pos = 30
-            for cls, cnt in class_count.items():
-                cv2.putText(frame, f"{cls}: {cnt}", (10, y_pos), 
-                          cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0,0,255), 2)
-                y_pos += 30
-            
-            out.write(frame)
-            frame_idx += 1
-            
-        cap.release()
-        out.release()
-        
-        # Generate report
-        result_text = "Final Counts\n\n"
-        for cls, cnt in total_counts.items():
-            result_text += f"{cls}: {cnt}\n"
-        result_text += f"\nTotal: {sum(total_counts.values())}"
-        
-        return temp_output, result_text
-        
+
+            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
+
+            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"Error: {str(e)}"
-    finally:
-        for f in os.listdir(temp_dir):
-            os.remove(os.path.join(temp_dir, f))
-        os.rmdir(temp_dir)
+        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>
-    """)
+    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")
             detect_image_button = gr.Button("Detect Image")
-            output_image = gr.Image(label="Detection Result")
-            
+            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="Video Result")
+            output_video = gr.Video(label="Output Video")
+            detect_video_button.click(fn=detect_objects_in_video, inputs=input_video, outputs=[output_video])
             
-        with gr.Column():
-            output_text = gr.Textbox(label="Counting Results")
-
-    detect_image_button.click(
-        fn=detect_combined,
-        inputs=input_image,
-        outputs=[output_image, output_text]
-    )
-    
-    detect_video_button.click(
-        fn=detect_objects_in_video,
-        inputs=input_video,
-        outputs=[output_video, output_text]
-    )
-
-iface.launch()
+iface.launch()