Update app.py

app.py

@@ -1,180 +1,283 @@
+# -*- coding: utf-8 -*-
+"""
+Aplikasi Gradio untuk Analisis Komparatif Deteksi Helm Keselamatan
+==================================================================
+
+Deskripsi:
+Aplikasi ini memungkinkan pengguna untuk mengunggah video dari lingkungan konstruksi
+dan membandingkan kinerja dua model AI (YOLOv5m dan YOLOv8m) dalam mendeteksi
+helm keselamatan secara real-time. Aplikasi ini dirancang untuk menjadi alat
+evaluasi yang praktis dan mudah digunakan.
+
+Fitur Utama:
+- Perbandingan langsung antara model Generalis (YOLOv5) dan Spesialis (YOLOv8).
+- Antarmuka pengguna (GUI) yang interaktif dan mudah dipahami.
+- Pemrosesan video dengan batasan durasi dan resolusi untuk stabilitas.
+- Menampilkan video hasil dengan anotasi deteksi (bounding box).
+- Memberikan ringkasan hasil analisis kualitatif dan kuantitatif.
+- Menyediakan dokumentasi, cara penggunaan, dan kredit yang jelas.
+
+Pengembang: Faisal Fahmi Yuliawan
+Berdasarkan Analisis pada Artikel Ilmiah.
+"""
+
+# --- 1. IMPORT LIBRARY ---
 import gradio as gr
-from ultralyticsplus import YOLO, render_result
+from ultralytics import YOLO
 import cv2
 import numpy as np
 import os
-import logging
 import tempfile
-import subprocess
-
-# Setup logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Muat model YOLOv8 dari Hugging Face
-logger.info("Memuat model YOLOv8 dari keremberke/yolov8m-hard-hat-detection...")
-model = YOLO('keremberke/yolov8m-hard-hat-detection')
-
-# Set parameter model
-model.overrides['conf'] = 0.25  # NMS confidence threshold
-model.overrides['iou'] = 0.45   # NMS IoU threshold
-model.overrides['agnostic_nms'] = False  # NMS class-agnostic
-model.overrides['max_det'] = 1000  # Maksimum deteksi per frame
-logger.info("Model berhasil dimuat")
-
-def convert_video_to_mp4(input_path):
-    """Konversi video input ke MP4 jika format tidak didukung."""
-    temp_mp4_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
-    ffmpeg_command = [
-        "ffmpeg",
-        "-y",  # Overwrite jika ada
-        "-i", input_path,
-        "-c:v", "libx264",
-        "-preset", "veryfast",
-        "-pix_fmt", "yuv420p",
-        "-t", "30",  # Batasi durasi maksimal 30 detik
-        temp_mp4_path
-    ]
-    result = subprocess.run(ffmpeg_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-    if result.returncode == 0 and os.path.exists(temp_mp4_path) and os.path.getsize(temp_mp4_path) > 0:
-        logger.info("Video dikonversi ke MP4: %s", temp_mp4_path)
-        os.remove(input_path)  # Hapus file asli setelah konversi
-        return temp_mp4_path
-    else:
-        logger.error("Konversi video gagal: %s", result.stderr)
-        return None
-
-def process_video(video_path):
+import time
+import logging
+
+# --- 2. SETUP & KONFIGURASI AWAL ---
+
+# Konfigurasi logging untuk memantau proses
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- 3. PEMUATAN MODEL AI ---
+# Memuat kedua model saat aplikasi dimulai untuk respons yang lebih cepat.
+# Ini menggunakan memori lebih, tetapi meningkatkan pengalaman pengguna.
+
+try:
+    logging.info("Memulai pemuatan model AI...")
+    # Model 1: Spesialis (Fokus pada Helm)
+    model_spesialis = YOLO('keremberke/yolov8m-hard-hat-detection')
+    model_spesialis.overrides['conf'] = 0.25
+    model_spesialis.overrides['iou'] = 0.45
+    logging.info("✅ Model Spesialis (YOLOv8m-HH) berhasil dimuat.")
+
+    # Model 2: Generalis (Mendeteksi banyak objek konstruksi)
+    model_generalis = YOLO('keremberke/yolov5m-construction-safety')
+    model_generalis.overrides['conf'] = 0.25
+    model_generalis.overrides['iou'] = 0.45
+    logging.info("✅ Model Generalis (YOLOv5m-CS) berhasil dimuat.")
+
+    # Membuat dictionary untuk kemudahan akses model
+    models = {
+        "YOLOv8m (Spesialis Helm)": model_spesialis,
+        "YOLOv5m (Generalis Konstruksi)": model_generalis
+    }
+    logging.info("Semua model siap digunakan.")
+
+except Exception as e:
+    logging.error(f"Gagal memuat salah satu model AI: {e}")
+    # Jika model gagal dimuat, aplikasi tidak dapat berjalan.
+    # Gradio akan menangani error ini dan menampilkannya di UI.
+    raise RuntimeError(f"Tidak dapat memuat model AI. Aplikasi tidak dapat dijalankan. Error: {e}")
+
+
+# --- 4. FUNGSI UTAMA PEMROSESAN VIDEO ---
+
+def process_video_and_analyze(video_path, selected_model_name, progress=gr.Progress(track_tqdm=True)):
+    """
+    Fungsi utama untuk memproses video, melakukan deteksi objek,
+    dan mengembalikan video hasil beserta analisisnya.
+    """
+    if video_path is None:
+        return None, "Status: Silakan unggah video terlebih dahulu.", ""
+
     try:
-        logger.info("Memulai pemrosesan video: %s", video_path)
+        logging.info(f"Memulai pemrosesan video: {video_path} menggunakan model: {selected_model_name}")
+        start_time = time.time()
+        
+        # Pilih model berdasarkan input dari UI
+        model = models[selected_model_name]
         
-        # Buka video
+        # Buka file video
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
-            logger.warning("Format video tidak didukung, mencoba konversi ke MP4...")
-            converted_path = convert_video_to_mp4(video_path)
-            if converted_path:
-                video_path = converted_path
-                cap = cv2.VideoCapture(video_path)
-            if not cap.isOpened():
-                logger.error("Gagal membuka video setelah konversi")
-                return None, "Error: Video tidak dapat dibuka meskipun dikonversi."
-        
-        # Dapatkan FPS dan batasi durasi
-        fps = cap.get(cv2.CAP_PROP_FPS) or 15
+            logging.error(f"Gagal membuka file video: {video_path}")
+            return None, "Error: Gagal membuka file video. Format mungkin tidak didukung.", ""
+
+        # Dapatkan properti video
+        fps = cap.get(cv2.CAP_PROP_FPS) or 30
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        max_duration = 30  # Detik
-        max_frames = int(fps * max_duration)
-        if total_frames > max_frames:
-            logger.warning("Video lebih dari 30 detik, dipotong ke %d frame", max_frames)
-            cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # Reset ke frame awal
-        
-        # Batasi resolusi ke 640x480
-        width, height = 640, 480
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         
-        # Buat file video sementara (.avi)
-        temp_video_path = tempfile.NamedTemporaryFile(suffix=".avi", delete=False).name
-        fourcc = cv2.VideoWriter_fourcc(*"XVID")
-        out = cv2.VideoWriter(temp_video_path, fourcc, fps, (width, height))
-        if not out.isOpened():
-            logger.error("Gagal membuka VideoWriter")
-            cap.release()
-            return None, "Error: Gagal membuat file video sementara."
+        # Batasi resolusi untuk performa yang lebih baik
+        target_width = 640
+        target_height = int(height * (target_width / width)) if width > 0 else 480
+
+        # Konfigurasi video output
+        # Menggunakan tempfile untuk file output sementara
+        temp_output_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        out = cv2.VideoWriter(temp_output_path, fourcc, fps, (target_width, target_height))
+
+        # Variabel untuk analisis
+        detection_count = 0
+        helm_detected_count = 0
         
-        # Proses frame
-        frame_count = 0
-        while cap.isOpened() and frame_count < max_frames:
+        progress(0, desc="Memulai Pemrosesan...")
+        for frame_idx in range(total_frames):
             ret, frame = cap.read()
             if not ret:
                 break
-            frame_count += 1
             
-            # Resize frame ke 640x480
-            frame = cv2.resize(frame, (width, height))
+            # Update progress bar
+            progress(frame_idx / total_frames, desc=f"Memproses Frame {frame_idx+1}/{total_frames}")
+
+            # Resize frame
+            frame_resized = cv2.resize(frame, (target_width, target_height))
+
+            # Lakukan prediksi (inferensi)
+            results = model.predict(frame_resized, verbose=False)
+            
+            # Render hasil deteksi ke frame
+            annotated_frame = results[0].plot()
             
-            # Skip frame untuk mengurangi beban
-            if frame_count % 3 != 0:  # Tulis frame asli untuk frame yang dilewati
-                out.write(frame)
-                continue
+            # Hitung deteksi
+            detection_count += len(results[0].boxes)
+            # Hitung deteksi helm secara spesifik
+            if selected_model_name == "YOLOv8m (Spesialis Helm)":
+                for box in results[0].boxes:
+                    class_id = int(box.cls)
+                    # Kelas '0' biasanya 'Hardhat' di model ini
+                    if model.names[class_id].lower() in ['hardhat', 'helmet']:
+                        helm_detected_count += 1
+            elif selected_model_name == "YOLOv5m (Generalis Konstruksi)":
+                 for box in results[0].boxes:
+                    class_id = int(box.cls)
+                    if model.names[class_id].lower() == 'helmet':
+                        helm_detected_count += 1
             
-            # Proses frame untuk deteksi
-            results = model.predict(frame)
-            annotated_frame = render_result(model=model, image=frame, result=results[0])
-            annotated_frame = np.array(annotated_frame)  # Konversi PIL ke NumPy
-            annotated_frame = cv2.cvtColor(annotated_frame, cv2.COLOR_RGB2BGR)  # Konversi RGB ke BGR
-            logger.debug("Menulis frame %d dengan ukuran %s", frame_count, annotated_frame.shape)
             out.write(annotated_frame)
-        
-        # Bersihkan
+            
+        end_time = time.time()
+        processing_time = end_time - start_time
+
+        # Tutup file video
         cap.release()
         out.release()
         
-        # Periksa apakah file sementara ada dan tidak kosong
-        if not os.path.exists(temp_video_path) or os.path.getsize(temp_video_path) == 0:
-            logger.error("File video sementara tidak valid atau kosong")
-            return None, "Error: File video sementara tidak valid."
-        
-        # Konversi .avi ke .mp4 dengan FFmpeg
-        final_video_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
-        ffmpeg_command = [
-            "ffmpeg",
-            "-y",  # Overwrite jika ada
-            "-i", temp_video_path,
-            "-c:v", "libx264",
-            "-preset", "veryfast",
-            "-pix_fmt", "yuv420p",
-            final_video_path
-        ]
-        result = subprocess.run(ffmpeg_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        if result.returncode != 0:
-            logger.error("FFmpeg gagal: %s", result.stderr)
-            os.remove(temp_video_path)
-            return None, f"Error: Konversi video gagal - {result.stderr}"
-        
-        # Bersihkan file sementara
-        os.remove(temp_video_path)
+        logging.info(f"Video berhasil diproses dalam {processing_time:.2f} detik.")
         
-        # Periksa apakah file final ada dan valid
-        if not os.path.exists(final_video_path) or os.path.getsize(final_video_path) == 0:
-            logger.error("File video final tidak valid atau kosong")
-            return None, "Error: File video final tidak valid."
-        
-        # Verifikasi file dengan FFmpeg (opsional untuk memastikan playable)
-        verify_command = ["ffprobe", "-v", "error", "-show_format", "-show_streams", final_video_path]
-        verify_result = subprocess.run(verify_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-        if verify_result.returncode != 0:
-            logger.warning("File video mungkin tidak playable: %s", verify_result.stderr)
-        
-        logger.info("Video selesai diproses: %s", final_video_path)
-        return final_video_path, "Video berhasil diproses! (Unduh jika tidak playable)"
+        # Siapkan teks analisis
+        analysis_text = f"""
+        ### Analisis Kinerja Model: {selected_model_name}
+
+        - **Waktu Proses Total:** {processing_time:.2f} detik
+        - **Total Frame Diproses:** {total_frames}
+        - **Jumlah Deteksi Keseluruhan:** {detection_count} objek
+        - **Jumlah Deteksi Helm:** {helm_detected_count} objek
+
+        **Catatan:**
+        - **Model Spesialis (YOLOv8m):** Diharapkan memiliki akurasi deteksi helm yang tinggi, namun hanya mendeteksi kelas terkait helm ('Hardhat', 'NO-Hardhat').
+        - **Model Generalis (YOLOv5m):** Mampu mendeteksi berbagai objek (11 kelas termasuk 'person', 'vest'), namun akurasi untuk 'helmet' mungkin lebih rendah karena fokusnya terbagi.
+        """
+
+        return temp_output_path, f"Status: Video berhasil diproses! ({processing_time:.2f} detik)", analysis_text
+
     except Exception as e:
-        logger.error("Error saat memproses video: %s", str(e))
-        return None, f"Error: {str(e)}"
-    finally:
-        if 'cap' in locals() and cap.isOpened():
-            cap.release()
-        if 'out' in locals() and out.isOpened():
-            out.release()
-
-# Setup antarmuka Gradio
-with gr.Blocks() as iface:
-    gr.Markdown("## Deteksi Helm Keselamatan")
+        logging.error(f"Terjadi error saat memproses video: {e}", exc_info=True)
+        return None, f"Error: Terjadi kesalahan internal - {e}", ""
+
+
+# --- 5. PEMBUATAN ANTARMUKA PENGGUNA (GRADIO UI) ---
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="sky")) as iface:
+    
+    # --- Bagian Judul dan Deskripsi ---
+    gr.Markdown(
+        """
+        # 🛡️ Analisis Komparatif Deteksi Helm Keselamatan
+        Selamat datang di prototipe aplikasi untuk analisis perbandingan model AI dalam mendeteksi helm keselamatan.
+        Aplikasi ini memungkinkan Anda untuk melihat perbedaan kinerja antara model AI yang **spesialis** (hanya untuk helm)
+        dan model AI yang **generalis** (untuk berbagai objek konstruksi).
+        """
+    )
+    
     with gr.Row():
         with gr.Column(scale=1):
-            video_input = gr.Video(label="Unggah Video (maks. 30 detik)", interactive=True)
-            detect_vid_btn = gr.Button("Detect Objects")
-            video_examples = gr.Examples(
-                examples=[["video.mp4"]],  # Sesuaikan dengan file di repositori
-                inputs=[video_input],
-                label="Contoh Video",
+            # --- Bagian Input Pengguna ---
+            gr.Markdown("### **Langkah 1: Konfigurasi & Unggah**")
+            
+            selected_model_ui = gr.Radio(
+                choices=list(models.keys()),
+                label="Pilih Model AI untuk Perbandingan",
+                value="YOLOv8m (Spesialis Helm)",
+                info="Pilih algoritma yang ingin Anda gunakan untuk mendeteksi objek."
             )
+            
+            video_input = gr.Video(
+                label="Unggah Video Anda",
+                info="Format video yang direkomendasikan adalah .mp4. Durasi maksimal ~30 detik."
+            )
+            
+            detect_btn = gr.Button("🚀 Mulai Deteksi", variant="primary")
+            
+            gr.Markdown("---")
+            gr.Markdown("### **Cara Penggunaan**")
+            gr.Markdown(
+                """
+                1.  **Pilih Model AI** yang ingin Anda uji dari opsi di atas.
+                2.  **Unggah file video** dari perangkat Anda atau **pilih contoh** di bawah.
+                3.  Klik tombol **"Mulai Deteksi"** dan tunggu proses selesai.
+                4.  Lihat **video hasil** dan **analisis kinerja** di sebelah kanan.
+                5.  Ulangi dengan model lain untuk melihat perbandingannya.
+                """
+            )
+            
         with gr.Column(scale=1):
-            video_output = gr.Video(label="Hasil Deteksi Helm Keselamatan")
-    status_text = gr.Textbox(label="Status", interactive=False)
-    detect_vid_btn.click(fn=process_video, inputs=video_input, outputs=[video_output, status_text])
+            # --- Bagian Output Hasil ---
+            gr.Markdown("### **Langkah 2: Lihat Hasil Deteksi**")
+            
+            video_output = gr.Video(label="Video Hasil Deteksi")
+            status_text = gr.Textbox(label="Status Proses", interactive=False)
+            
+            gr.Markdown("---")
+            gr.Markdown("### **Ringkasan Analisis**")
+            analysis_output = gr.Markdown(label="Analisis Kinerja")
+
+    # --- Bagian Contoh Video ---
+    gr.Examples(
+        examples=[
+            [os.path.join(os.path.dirname(__file__), "video_contoh_1.mp4"), "YOLOv8m (Spesialis Helm)"],
+            [os.path.join(os.path.dirname(__file__), "video_contoh_2.mp4"), "YOLOv5m (Generalis Konstruksi)"]
+        ],
+        inputs=[video_input, selected_model_ui],
+        outputs=[video_output, status_text, analysis_output],
+        fn=process_video_and_analyze,
+        cache_examples=True,
+        label="Contoh Video (Klik untuk mencoba)"
+    )
+
+    # --- Bagian Informasi dan Kredit ---
+    with gr.Accordion("ℹ️ Informasi, Kredit, dan Potensi Pengembangan", open=False):
+        gr.Markdown(
+            """
+            ### **Identitas Prototipe**
+            - **Pengembang:** Faisal Fahmi Yuliawan (sebagai bagian dari studi ilmiah).
+            - **Tujuan:** Menyediakan alat bantu visual untuk membandingkan kinerja model AI dalam konteks keselamatan kerja (K3), khususnya deteksi helm.
+            - **Relevansi:** Masalah kepatuhan penggunaan APD (Alat Pelindung Diri) seperti helm adalah kasus nyata dan krusial di industri konstruksi untuk mencegah kecelakaan fatal.
+
+            ### **Kredit Pihak Ketiga**
+            - **Model AI:** - `keremberke/yolov8m-hard-hat-detection` (Model Spesialis) dari Hugging Face.
+                - `keremberke/yolov5m-construction-safety` (Model Generalis) dari Hugging Face.
+            - **Teknologi:** - **Ultralytics YOLO:** Framework utama untuk model AI.
+                - **Gradio:** Framework untuk membangun antarmuka web interaktif ini.
+                - **OpenCV & FFmpeg:** Untuk pemrosesan dan manipulasi video.
+            
+            ### **Potensi Pengembangan & Komersialisasi**
+            - **Skalabilitas:** Arsitektur aplikasi ini dapat dengan mudah diperluas untuk mencakup lebih banyak model AI atau jenis APD lain (misalnya, rompi, sepatu bot, sarung tangan).
+            - **Integrasi:** Dapat diintegrasikan dengan sistem CCTV di lokasi konstruksi untuk pemantauan otomatis dan sistem peringatan *real-time*.
+            - **Potensi Bisnis:** Memiliki potensi komersial sebagai produk SaaS (*Software as a Service*) untuk perusahaan konstruksi yang ingin meningkatkan standar K3 dan melakukan audit kepatuhan secara digital.
+            """
+        )
+
+    # --- Hubungkan Aksi Tombol ke Fungsi ---
+    detect_btn.click(
+        fn=process_video_and_analyze,
+        inputs=[video_input, selected_model_ui],
+        outputs=[video_output, status_text, analysis_output]
+    )
 
-    iface.launch()
 
-# Luncurkan aplikasi
+# --- 6. LUNCURKAN APLIKASI ---
 if __name__ == "__main__":
-    iface.launch()
+    # Untuk menjalankan, simpan kode ini sebagai file .py (misal: app.py)
+    # Buat 2 file video contoh: video_contoh_1.mp4 dan video_contoh_2.mp4 di folder yang sama.
+    # Jalankan dari terminal dengan: python app.py
+    iface.launch(debug=True, share=True)