Update app.py

app.py

@@ -1,76 +1,108 @@
 import gradio as gr
-import supervision as sv
-import numpy as np
-import cv2
-from inference import get_roboflow_model
-
-# Replace with your actual Roboflow model ID and API key
-model_id = "nescafe-4base/46"  # Replace with your Roboflow model ID
-api_key = "Otg64Ra6wNOgDyjuhMYU"    # Replace with your Roboflow API key
-
-# Load the Roboflow model using the get_roboflow_model function
-model = get_roboflow_model(model_id=model_id, api_key=api_key)
-
-# Define the callback function for the SAHI slicer
-def callback(image_slice: np.ndarray) -> sv.Detections:
-    # Run inference on the image slice
-    results = model.infer(image_slice)
-    
-    # Check if results are in the expected format and handle accordingly
-    if isinstance(results, tuple):
-        results = results[0]  # Extract the detections from the tuple if necessary
-    
-    # If the results are a list (likely from Roboflow), access them correctly
-    detections = []
-    if isinstance(results, list):
-        for result in results:
-            # Ensure each result is processed into a Detections object
-            detections.extend(sv.Detections.from_inference(result))
-    
-    # Return the list of detections
-    return detections
-
-# Initialize the SAHI Inference Slicer
-slicer = sv.InferenceSlicer(callback=callback)
-
-# Function to handle image processing, inference, and annotation
-def process_image(image):
-    # Convert the PIL image to OpenCV format (BGR)
-    image = np.array(image)
-    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-
-    # Run inference using SAHI (splitting the image into slices)
-    sliced_detections = slicer(image=image)
-
-    # Annotate the detections with bounding boxes and labels
-    label_annotator = sv.LabelAnnotator()
-    box_annotator = sv.BoxAnnotator()
-    
-    annotated_image = box_annotator.annotate(scene=image.copy(), detections=sliced_detections)
-    annotated_image = label_annotator.annotate(scene=annotated_image, detections=sliced_detections)
-
-    # Convert the annotated image back to RGB for display in Gradio
-    result_image = cv2.cvtColor(annotated_image, cv2.COLOR_BGR2RGB)
-
-    # Count the number of objects detected
+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 = {}
-    for detection in sliced_detections:
-        class_name = detection.class_name
-        class_count[class_name] = class_count.get(class_name, 0) + 1
-
-    total_count = sum(class_count.values())
-
-    return result_image, class_count, total_count
-
-# Gradio interface
-iface = gr.Interface(
-    fn=process_image,
-    inputs=gr.Image(type="pil", label="Upload Image"),
-    outputs=[gr.Image(type="pil", label="Annotated Image"), 
-             gr.JSON(label="Object Count"), 
-             gr.Number(label="Total Objects Detected")],
-    live=True
-)
-
-# Launch the Gradio interface
-iface.launch()
+    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()