Update app.py

app.py

@@ -1,118 +1,111 @@
-import gradio as gr
+from PIL import Image, ImageDraw, ImageFont
 import numpy as np
-
-# Define functions to wrap the private space's interfaces
-def cataract_analyzer(image):
-    private_space_id = "EyeMedicalDiagnosis/cataract_analyzer"
-    private_space = gr.Interface.load(private_space_id)
-    result = private_space(image)
-    return parse_cataract_result(result, image)
-
-def glaucoma_analyzer(image):
-    private_space_id = "EyeMedicalDiagnosis/glaucoma_analyzer"
-    private_space = gr.Interface.load(private_space_id)
-    result = private_space(image)
-    return parse_glaucoma_result(result, image)
-
-def rlfd_analyzer(image):
-    private_space_id = "EyeMedicalDiagnosis/rlfd_analyzer"
-    private_space = gr.Interface.load(private_space_id)
-    result = private_space(image)
-    return parse_rlfd_result(result, image)
-
-def parse_cataract_result(result, image):
-    if isinstance(result, list) and len(result) == 7:
-        return result
-    else:
-        return [image, "Error: Invalid result", image, 0, 0, 0, ""]
-
-def parse_glaucoma_result(result, image):
-    if isinstance(result, list) and len(result) == 5:
-        return result
-    else:
-        return [image, "Error: Invalid result", "0", "0", "0"]
-
-def parse_rlfd_result(result, image):
-    if isinstance(result, list) and len(result) == 8:
-        return result
-    else:
-        return [image, image, "Error: Invalid result", image, "0", image, "0", image, "0"]
-
-# Create the public interface with custom layout
-with gr.Blocks() as demo:
-    gr.Markdown("## Medical Image Analyzer")
-    gr.Markdown("Choose which analyzer you want to use:")
-
-    with gr.Tab("Cataract Analyzer"):
-        with gr.Row():
-            image_input_cataract = gr.Image(type="numpy", label="Upload an Image")
-            submit_btn_cataract = gr.Button("Submit")
-
-        with gr.Row():
-            result_image_cataract = gr.Image(type="numpy", label="Image with Prediction and Bounding Box", scale=2)
-            cataract_label = gr.Textbox(label="Cataract Prediction", scale=1)
-
-        with gr.Row():
-            blended_image_cataract = gr.Image(type="numpy", label="Image with Masked Area", scale=2)
-
-        with gr.Column():
-            red_quantity_cataract = gr.Slider(label="Red Quantity", minimum=0, maximum=255, interactive=False)
-            green_quantity_cataract = gr.Slider(label="Green Quantity", minimum=0, maximum=255, interactive=False)
-            blue_quantity_cataract = gr.Slider(label="Blue Quantity", minimum=0, maximum=255, interactive=False)
-
+import cv2
+import tensorflow as tf
+import gradio as gr
+import io
+
+def load_model(model_path):
+    model = tf.keras.models.load_model(model_path)
+    model.compile(optimizer=tf.keras.optimizers.Adam(), loss=tf.keras.losses.BinaryCrossentropy(), metrics=['accuracy'])
+    return model
+
+def get_model_summary(model):
+    stream = io.StringIO()
+    model.summary(print_fn=lambda x: stream.write(x + "\n"))
+    summary_str = stream.getvalue()
+    stream.close()
+    return summary_str
+
+def get_input_shape(model):
+    input_shape = model.input_shape[1:]  # Skip the batch dimension
+    return input_shape
+
+def preprocess_image(image, input_shape):
+    img = np.array(image)
+    num_channels = input_shape[-1]
+
+    if num_channels == 1:  # Model expects grayscale
+        if len(img.shape) == 2:  # Image is already grayscale
+            img = np.expand_dims(img, axis=-1)
+        elif img.shape[2] == 3:  # Convert RGB to grayscale
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+            img = np.expand_dims(img, axis=-1)
+    elif num_channels == 3:  # Model expects RGB
+        if len(img.shape) == 2:  # Convert grayscale to RGB
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
+        elif img.shape[2] == 1:  # Convert single channel to RGB
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
+    
+    img_resized = cv2.resize(img, (input_shape[0], input_shape[1]))
+    img_normalized = img_resized / 255.0
+    img_batch = np.expand_dims(img_normalized, axis=0)
+    
+    return img_batch
+
+def diagnose_image(image, model, input_shape):
+    img_batch = preprocess_image(image, input_shape)
+    prediction = model.predict(img_batch)
+    glaucoma_probability = prediction[0][0]
+    result_text = f"Probability of glaucoma: {glaucoma_probability:.2%}"
+    
+    img_display = np.array(image)
+    if img_display.shape[2] == 1:  # Convert to RGB for display
+        img_display = cv2.cvtColor(img_display.squeeze(), cv2.COLOR_GRAY2RGB)
+    image_pil = Image.fromarray(img_display)
+    draw = ImageDraw.Draw(image_pil)
+    font = ImageFont.load_default()
+    
+    text = f"{glaucoma_probability:.2%}"
+    text_bbox = draw.textbbox((0, 0), text, font=font)
+    text_size = (text_bbox[2] - text_bbox[0], text_bbox[3] - text_bbox[1])
+    
+    rect_width = 200
+    rect_height = 100
+    rect_x = (image_pil.width - rect_width) // 2
+    rect_y = (image_pil.height - rect_height) // 2
+    
+    draw.rectangle([rect_x, rect_y, rect_x + rect_width, rect_y + rect_height], outline="red", width=3)
+    
+    text_x = rect_x + (rect_width - text_size[0]) // 2
+    text_y = rect_y + (rect_height - text_size[1]) // 2
+    
+    draw.text((text_x, text_y), text, fill="red", font=font)
+    
+    return image_pil, result_text
+
+def main():
+    with gr.Blocks() as demo:
+        gr.Markdown("# Glaucoma Detection App")
+        gr.Markdown("Upload an eye image to detect the probability of glaucoma.")
+        
         with gr.Row():
-            raw_response_cataract = gr.Textbox(label="Raw Response", scale=2)
-
-        submit_btn_cataract.click(
-            cataract_analyzer,
-            inputs=image_input_cataract,
-            outputs=[
-                result_image_cataract, cataract_label, blended_image_cataract,
-                red_quantity_cataract, green_quantity_cataract, blue_quantity_cataract, raw_response_cataract
-            ]
-        )
-
-    with gr.Tab("Glaucoma Analyzer"):
-        image_input_glaucoma = gr.Image(type="numpy", label="Input Image")
-        submit_btn_glaucoma = gr.Button("Submit")
-
-        segmented_image_glaucoma = gr.Image(type="numpy", label="Segmented Image")
-        cup_area = gr.Textbox(label="Cup Area")
-        disk_area = gr.Textbox(label="Disk Area")
-        rim_area = gr.Textbox(label="Rim Area")
-        rim_to_disk_ratio = gr.Textbox(label="Rim/Disk Ratio")
-
-        submit_btn_glaucoma.click(
-            glaucoma_analyzer,
-            inputs=image_input_glaucoma,
-            outputs=[segmented_image_glaucoma, cup_area, disk_area, rim_area, rim_to_disk_ratio]
-        )
-
-    with gr.Tab("RLFD Analyzer"):
-        image_input_rlfd = gr.Image(type="pil", label="Upload an Image")
-        submit_btn_rlfd = gr.Button("Submit")
-
-        enhanced_image_with_line = gr.Image(type="numpy", label="Enhanced Image with Diagonal Lines")
-        top_section_image = gr.Image(type="numpy", label="Top Section")
-        top_section_score = gr.Textbox(label="Top Section Score")
-        bottom_section_image = gr.Image(type="numpy", label="Bottom Section")
-        bottom_section_score = gr.Textbox(label="Bottom Section Score")
-        left_section_image = gr.Image(type="numpy", label="Left Section")
-        left_section_score = gr.Textbox(label="Left Section Score")
-        right_section_image = gr.Image(type="numpy", label="Right Section")
-        right_section_score = gr.Textbox(label="Right Section Score")
-
-        submit_btn_rlfd.click(
-            rlfd_analyzer,
-            inputs=image_input_rlfd,
-            outputs=[
-                enhanced_image_with_line,
-                top_section_image, top_section_score,
-                bottom_section_image, bottom_section_score,
-                left_section_image, left_section_score,
-                right_section_image, right_section_score
-            ]
-        )
-
-# Launch the public interface
-demo.launch()
+            model_file = gr.File(label="Upload Model (.h5 or .keras)")
+            load_model_btn = gr.Button("Load Model")
+            model_info = gr.Markdown()
+        
+        image = gr.Image(type="pil", label="Upload Image")
+        submit_btn = gr.Button("Diagnose")
+        result = gr.Textbox(label="Diagnosis Result")
+        
+        def load_and_display_model_info(file):
+            model = load_model(file.name)
+            model_summary = get_model_summary(model)
+            input_shape = get_input_shape(model)
+            return model, model_summary, input_shape
+        
+        model = gr.State(None)
+        input_shape = gr.State(None)
+        
+        def diagnose_and_display(image, model, input_shape):
+            return diagnose_image(image, model, input_shape)
+        
+        load_model_btn.click(fn=load_and_display_model_info, inputs=model_file, outputs=[model, model_info, input_shape])
+        submit_btn.click(fn=diagnose_and_display, inputs=[image, model, input_shape], outputs=[image, result])
+        
+        gr.Markdown("### Glaucoma Analyzer V.1.0.0 by Thariq Arian")
+        
+    demo.launch()
+
+if __name__ == "__main__":
+    main()