Update app.py

app.py

@@ -46,38 +46,47 @@ transform = transforms.Compose([
     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
 ])
 
-def predict(data):
+def predict(image):
     try:
-        if not isinstance(data, list) or len(data) == 0:
-            return {"error": "Input data should be a non-empty list."}
-        
-        image_input = data[0].get('image', None)
-        if not image_input:
-            return {"error": "No image provided."}
-
-        print(f"Received image input: {image_input}")
+        print(f"Received image input: {image}")
 
         # Check if the input is a PIL Image type
-        if isinstance(image_input, Image.Image):
-            print(f"Image is already loaded as PIL Image: {image_input}")
+        if isinstance(image, Image.Image):
+            print(f"Image is already loaded as PIL Image: {image}")
         else:
-            # Check if the input contains a base64-encoded string or URL
-            if image_input.startswith("http"):  # URL case
+            # Try to handle base64-encoded image
+            if isinstance(image, dict) and image.get("data"):
+                try:
+                    image_data = base64.b64decode(image["data"])
+                    image = Image.open(BytesIO(image_data))
+                    print(f"Decoded base64 image: {image}")
+                except Exception as e:
+                    print(f"Error decoding base64 image: {e}")
+                    return json.dumps({"error": f"Error decoding base64 image: {e}"})
+
+            # Try to fetch the image from a URL
+            elif isinstance(image, str) and image.startswith("http"):
                 try:
-                    response = requests.get(image_input)
+                    response = requests.get(image)
                     image = Image.open(BytesIO(response.content))
                     print(f"Fetched image from URL: {image}")
                 except Exception as e:
                     print(f"Error fetching image from URL: {e}")
-                    return {"error": f"Error fetching image from URL: {e}"}
-            else:  # Assuming it is base64-encoded image data
+                    return json.dumps({"error": f"Error fetching image from URL: {e}"})
+
+            # Try to load the image from a local file path
+            elif isinstance(image, str) and os.path.isfile(image):
                 try:
-                    image_data = base64.b64decode(image_input)
-                    image = Image.open(BytesIO(image_data))
-                    print(f"Decoded base64 image: {image}")
+                    image = Image.open(image)
+                    print(f"Loaded image from local path: {image}")
                 except Exception as e:
-                    print(f"Error decoding base64 image: {e}")
-                    return {"error": f"Error decoding base64 image: {e}"}
+                    print(f"Error loading image from local path: {e}")
+                    return json.dumps({"error": f"Error loading image from local path: {e}"})
+
+            # Validate that the image is correctly loaded
+            if not isinstance(image, Image.Image):
+                print("Invalid image format received.")
+                return json.dumps({"error": "Invalid image format received."})
 
         # Apply transformations
         image = transform(image).unsqueeze(0)
@@ -91,20 +100,20 @@ def predict(data):
             print(f"Prediction output: {outputs}, Predicted class: {predicted_class}")
 
         if predicted_class == 0:
-            return {"result": "The photo you've sent is of fall army worm with problem ID 126."}
+            return json.dumps({"result": "The photo you've sent is of fall army worm with problem ID 126."})
         elif predicted_class == 1:
-            return {"result": "The photo you've sent is of a healthy maize image."}
+            return json.dumps({"result": "The photo you've sent is of a healthy maize image."})
         else:
-            return {"error": "Unexpected class prediction."}
+            return json.dumps({"error": "Unexpected class prediction."})
     except Exception as e:
         print(f"Error processing image: {e}")
-        return {"error": f"Error processing image: {e}"}
+        return json.dumps({"error": f"Error processing image: {e}"})
 
 # Create the Gradio interface
 iface = gr.Interface(
     fn=predict,
-    inputs=gr.JSON(label="Input JSON"),
-    outputs=gr.JSON(label="Prediction Result"),
+    inputs=gr.Image(type="pil", label="Upload an image or provide a URL or local path"),
+    outputs=gr.Textbox(label="Prediction Result"),
     live=True,
     title="Maize Anomaly Detection",
     description="Upload an image of maize to detect anomalies like disease or pest infestation. You can provide local paths, URLs, or base64-encoded images."
@@ -112,4 +121,3 @@ iface = gr.Interface(
 
 # Launch the Gradio interface 
 iface.launch(share=True, show_error=True)
-