app.py

import gradio as gr
from roboflow import Roboflow
import tempfile
import os
from sahi.slicing import slice_image
import numpy as np
import cv2

# Inisialisasi Roboflow (for model path)
rf = Roboflow(api_key="Otg64Ra6wNOgDyjuhMYU")
project = rf.workspace("alat-pelindung-diri").project("nescafe-4base")
model = project.version(16).model

# Fungsi untuk melakukan Non-Maximum Suppression (NMS)
def apply_nms(predictions, iou_threshold=0.5):
    boxes = []
    scores = []
    classes = []

    # Extract boxes, scores, and class info
    for prediction in predictions:
        boxes.append(prediction['bbox'])
        scores.append(prediction['confidence'])
        classes.append(prediction['class'])

    boxes = np.array(boxes)
    scores = np.array(scores)
    classes = np.array(classes)

    # Perform NMS using OpenCV
    indices = cv2.dnn.NMSBoxes(boxes.tolist(), scores.tolist(), score_threshold=0.25, nms_threshold=iou_threshold)
    nms_predictions = []

    for i in indices.flatten():
        nms_predictions.append({
            'class': classes[i],
            'bbox': boxes[i],
            'confidence': scores[i]
        })

    return nms_predictions

# Fungsi untuk deteksi objek menggunakan Roboflow Model
def detect_objects(image):
    # Menyimpan gambar sementara
    with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
        image.save(temp_file, format="JPEG")
        temp_file_path = temp_file.name

    # Slice gambar menjadi potongan-potongan kecil
    slice_image_result = slice_image(
        image=temp_file_path,
        output_file_name="sliced_image",
        output_dir="/tmp/sliced/",
        slice_height=256,
        slice_width=256,
        overlap_height_ratio=0.1,
        overlap_width_ratio=0.1
    )

    # Mendapatkan path-potongan gambar
    sliced_image_paths = slice_image_result['sliced_image_paths']

    # Menyimpan semua prediksi untuk setiap potongan gambar
    all_predictions = []

    # Prediksi pada setiap potongan gambar
    for sliced_image_path in sliced_image_paths:
        predictions = model.predict(image_path=sliced_image_path).json()
        all_predictions.extend(predictions['predictions'])

    # Aplikasikan NMS untuk menghapus duplikat deteksi
    postprocessed_predictions = apply_nms(all_predictions, iou_threshold=0.5)

    # Annotate gambar dengan hasil prediksi
    annotated_image = model.annotate_image_with_predictions(temp_file_path, postprocessed_predictions)

    # Simpan gambar hasil annotasi
    output_image_path = "/tmp/prediction.jpg"
    annotated_image.save(output_image_path)

    # Menghitung jumlah objek per kelas
    class_count = {}
    for detection in postprocessed_predictions:
        class_name = detection['class']
        if class_name in class_count:
            class_count[class_name] += 1
        else:
            class_count[class_name] = 1

    # Hasil perhitungan objek
    result_text = "Jumlah objek per kelas:\n"
    for class_name, count in class_count.items():
        result_text += f"{class_name}: {count} objek\n"

    # Hapus file sementara
    os.remove(temp_file_path)

    return output_image_path, result_text

# Membuat antarmuka Gradio
iface = gr.Interface(
    fn=detect_objects,                         # Fungsi yang dipanggil saat gambar diupload
    inputs=gr.Image(type="pil"),               # Input berupa gambar
    outputs=[gr.Image(), gr.Textbox()],        # Output gambar dan teks
    live=True                                    # Menampilkan hasil secara langsung
)

# Menjalankan antarmuka
iface.launch()