app.py

import gradio as gr
from dotenv import load_dotenv
from roboflow import Roboflow
import tempfile
import os
import requests
from PIL import Image

# Muat variabel lingkungan dari file .env
load_dotenv()
api_key = os.getenv("ROBOFLOW_API_KEY")
workspace = os.getenv("ROBOFLOW_WORKSPACE")
project_name = os.getenv("ROBOFLOW_PROJECT")
model_version = int(os.getenv("ROBOFLOW_MODEL_VERSION"))

# Inisialisasi Roboflow menggunakan data yang diambil dari secrets
rf = Roboflow(api_key=api_key)
project = rf.workspace(workspace).project(project_name)
model = project.version(model_version).model

# Fungsi untuk memotong gambar menjadi potongan-potongan kecil
def slice_image(image, slice_size=512, overlap=0):
    width, height = image.size
    slices = []

    step = slice_size - overlap

    for top in range(0, height, step):
        for left in range(0, width, step):
            bottom = min(top + slice_size, height)
            right = min(left + slice_size, width)
            slices.append((left, top, right, bottom))

    return slices

# Fungsi untuk menangani input dan output gambar
def detect_objects(image):
    slice_size = 512
    overlap = 50

    # Potong gambar menjadi bagian kecil
    slices = slice_image(image, slice_size, overlap)
    results = []
    class_count = {}
    total_count = 0

    for i, (left, top, right, bottom) in enumerate(slices):
        sliced_image = image.crop((left, top, right, bottom))

        # Simpan gambar slice sementara
        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
            sliced_image.save(temp_file, format="JPEG")
            temp_file_path = temp_file.name

        try:
            # Lakukan prediksi pada setiap slice
            predictions = model.predict(temp_file_path, confidence=60, overlap=80).json()

            for prediction in predictions['predictions']:
                prediction["left"] += left
                prediction["top"] += top
                prediction["right"] += left
                prediction["bottom"] += top

                results.append(prediction)

                # Perbarui jumlah objek per kelas
                class_name = prediction['class']
                class_count[class_name] = class_count.get(class_name, 0) + 1
                total_count += 1
        except requests.exceptions.HTTPError as http_err:
            return f"HTTP error occurred: {http_err}", None
        except Exception as err:
            return f"An error occurred: {err}", None
        finally:
            os.remove(temp_file_path)

    # Gabungkan hasil deteksi
    result_text = "Product Nestle\n\n"
    for class_name, count in class_count.items():
        result_text += f"{class_name}: {count}\n"
    result_text += f"\nTotal Product Nestle: {total_count}"

    # Kembalikan hasil
    return image, result_text

# Membuat antarmuka Gradio dengan tata letak fleksibel
with gr.Blocks() as iface:
    with gr.Row():
        with gr.Column():
            input_image = gr.Image(type="pil", label="Input Image")
        with gr.Column():
            output_image = gr.Image(label="Detect Object")
        with gr.Column():
            output_text = gr.Textbox(label="Counting Object")

    # Tombol untuk memproses input
    detect_button = gr.Button("Detect")

    # Hubungkan tombol dengan fungsi deteksi
    detect_button.click(
        fn=detect_objects,
        inputs=input_image,
        outputs=[output_image, output_text]
    )

# Menjalankan antarmuka
iface.launch()