app.py

import gradio as gr
import os
import numpy as np
from cataract import combined_prediction, save_cataract_prediction_to_db, predict_object_detection
from glaucoma import combined_prediction_glaucoma, submit_to_db, predict_image
from database import get_db_data, format_db_data, clear_database
from chatbot import chatbot, toggle_visibility, update_patient_history, generate_voice_response 
from PIL import Image

# Define the custom theme
theme = gr.themes.Soft(
    primary_hue="neutral",
    secondary_hue="neutral",
    neutral_hue="gray",
    font=[gr.themes.GoogleFont('Libre Franklin'), gr.themes.GoogleFont('Public Sans'), 'system-ui', 'sans-serif']
).set(
    body_background_fill="#ffffff",
    block_background_fill="#0a2b42",
    block_border_width="1px",
    block_title_background_fill="#0a2b42",
    input_background_fill="#ffffff",
    button_secondary_background_fill="#0a2b42",
    border_color_primary="#800080",
    background_fill_secondary="#ffffff",
    color_accent_soft="transparent"
)

# Define custom CSS
css = """
body {
    color: #0a2b42;  /* Dark blue font */
}
.light body {
    color: #0a2b42;  /* Dark blue font */
}
input, textarea {
    background-color: #ffffff !important;  /* White background for text boxes */
    color: #0a2b42 !important;  /* Dark blue font for text boxes */
}
"""

logo_url = "https://huggingface.co/spaces/Nexus-Community/nexus-main/resolve/main/Nexus-Hub.png"
db_path_cataract = "cataract_results.db"
db_path_glaucoma = "glaucoma_results.db"

def display_db_data():
    """Fetch and format the data from the database for display."""
    glaucoma_data, cataract_data = get_db_data(db_path_glaucoma, db_path_cataract)
    formatted_data = format_db_data(glaucoma_data, cataract_data)
    return formatted_data

def check_db_status():
    """Check the status of the databases and return a status message."""
    cataract_status = "Loaded" if os.path.exists(db_path_cataract) else "Not Loaded"
    glaucoma_status = "Loaded" if os.path.exists(db_path_glaucoma) else "Not Loaded"
    return f"Cataract Database: {cataract_status}\nGlaucoma Database: {glaucoma_status}"

def toggle_input_visibility(input_type):
    if input_type == "Voice":
        return gr.update(visible=True), gr.update(visible=False)
    else:
        return gr.update(visible=False), gr.update(visible=True)
        
def process_image(image):
    # Run the analyzer model
    blended_image, red_quantity, green_quantity, blue_quantity, raw_response, stage, save_message, debug_info = combined_prediction(image)
    
    # Run the object detection model
    predicted_image_od, raw_response_od = predict_object_detection(image)
    
    return blended_image, red_quantity, green_quantity, blue_quantity, raw_response, stage, save_message, debug_info, predicted_image_od, raw_response_od

with gr.Blocks(theme=theme) as demo:
    gr.HTML(f"<img src='{logo_url}' alt='Logo' width='150'/>")  
    gr.Markdown("## Wellness-Nexus V.1.0")
    gr.Markdown("This app helps people to diagnose their cataract and glaucoma, both respectively #1 and #2 cause of blindness in the world. You could try our diagnostic model by downloading test image on our Huggingface Repo File.")
    gr.Markdown("We were sorry that we provide the demo in diffrent file because we misunderstood the 5 minutes rule. we thought that 5 minutes are excluding demo. you can see our demo here : https://youtu.be/yknUdPnbXFg")
    
    with gr.Tab("Cataract Screener and Analyzer"):
        with gr.Row():
            image_input = gr.Image(type="numpy", label="Upload an Image")
            submit_btn = gr.Button("Submit")
            gr.Examples([["test-cataract-image.jpg"], ["test-cataract-image2.jpg"], ["test-cataract-image3.jpg"], ["test-cataract-image4.jpg"]], inputs=[image_input],label='Or use one of these examples:')

        with gr.Row():
            segmented_image_cataract = gr.Image(type="numpy", label="Segmented Image")
            predicted_image_od = gr.Image(type="numpy", label="Predicted Image")
        
        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)

        with gr.Row():
            cataract_stage = gr.Textbox(label="Cataract Stage", interactive=False)
            raw_response_cataract = gr.Textbox(label="Raw Response", interactive=False)
            submit_value_btn_cataract = gr.Button("Submit Values to Database")
            db_response_cataract = gr.Textbox(label="Database Response")
            debug_cataract = gr.Textbox(label="Debug Message", interactive=False)

        submit_btn.click(
            process_image,
            inputs=image_input,
            outputs=[
                segmented_image_cataract, red_quantity_cataract, green_quantity_cataract, blue_quantity_cataract, raw_response_cataract, cataract_stage, db_response_cataract, debug_cataract, predicted_image_od
            ]
        )

        submit_value_btn_cataract.click(
            lambda img, red, green, blue, stage: save_cataract_prediction_to_db(Image.fromarray(img), red, green, blue, stage),
            inputs=[segmented_image_cataract, red_quantity_cataract, green_quantity_cataract, blue_quantity_cataract, cataract_stage],
            outputs=[db_response_cataract, debug_cataract]
        )

    with gr.Tab("Glaucoma Analyzer and Screener"):
        with gr.Row():
            image_input = gr.Image(type="numpy", label="Upload an Image")
            mask_threshold_slider = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, value=0.5, label="Mask Threshold")
            gr.Examples([["test-glaucoma-image.jpg"], ["test-glaucoma-image2.jpg"], ["test-glaucoma-image3.jpg"], ["test-glaucoma-image4.jpg"]], inputs=[image_input],label='Or use one of these examples:')
            
        with gr.Row():
            submit_btn_segmentation = gr.Button("Submit Segmentation")
            submit_btn_od = gr.Button("Submit Object Detection")
    
        with gr.Row():
            segmented_image = gr.Image(type="numpy", label="Segmented Image")
            predicted_image_od = gr.Image(type="numpy", label="Predicted Image")
    
        with gr.Row():
            raw_response_od = gr.Textbox(label="Raw Result")
            
        with gr.Column():
            cup_area = gr.Textbox(label="Cup Area")
            disk_area = gr.Textbox(label="Disk Area")
            rim_area = gr.Textbox(label="Rim Area")
            rim_to_disc_ratio = gr.Textbox(label="Rim to Disc Ratio")
            ddls_stage = gr.Textbox(label="DDLS Stage")
            
        with gr.Column():
            submit_value_btn = gr.Button("Submit Values to Database")
            db_response = gr.Textbox(label="Database Response")
            debug_glaucoma = gr.Textbox(label="Debug Message", interactive=False)
    
        def process_segmentation_image(img, mask_thresh):
            # Run the segmentation model
            return combined_prediction_glaucoma(img, mask_thresh)
    
        def process_od_image(img):
            # Run the object detection model
            image_with_boxes, raw_predictions = predict_image(img)
            return image_with_boxes, raw_predictions
    
        submit_btn_segmentation.click(
            fn=process_segmentation_image,
            inputs=[image_input, mask_threshold_slider],
            outputs=[
                segmented_image, cup_area, disk_area, rim_area, rim_to_disc_ratio, ddls_stage
            ]
        )

        submit_btn_od.click(
            fn=process_od_image,
            inputs=[image_input],
            outputs=[
                predicted_image_od, raw_response_od
            ]
        )

        submit_value_btn.click(
            lambda img, cup, disk, rim, ratio, stage: submit_to_db(img, cup, disk, rim, ratio, stage),
            inputs=[image_input, cup_area, disk_area, rim_area, rim_to_disc_ratio, ddls_stage],
            outputs=[db_response, debug_glaucoma]
        )

    with gr.Tab("Chatbot"):
        with gr.Row():
            input_type_dropdown = gr.Dropdown(label="Input Type", choices=["Voice", "Text"], value="Voice")
            tts_model_dropdown = gr.Dropdown(label="TTS Model", choices=["Ryan (ESPnet)", "Nithu (Custom)"], value="Nithu (Custom)")
            submit_btn_chatbot = gr.Button("Submit")

        with gr.Row():
            audio_input = gr.Audio(type="filepath", label="Record your voice", visible=True)
            text_input = gr.Textbox(label="Type your question", visible=False)

        with gr.Row():
            answer_textbox = gr.Textbox(label="Answer")
            answer_audio = gr.Audio(label="Answer as Speech", type="filepath")
            generate_voice_btn = gr.Button("Generate Voice Response")

        with gr.Row():
            log_messages_textbox = gr.Textbox(label="Log Messages", lines=10)
            db_status_textbox = gr.Textbox(label="Database Status", interactive=False)

        input_type_dropdown.change(
            fn=toggle_input_visibility,
            inputs=[input_type_dropdown],
            outputs=[audio_input, text_input]
        )

        submit_btn_chatbot.click(
            fn=chatbot,
            inputs=[audio_input, input_type_dropdown, text_input],
            outputs=[answer_textbox, db_status_textbox]
        )

        generate_voice_btn.click(
            fn=generate_voice_response,
            inputs=[tts_model_dropdown, answer_textbox],
            outputs=[answer_audio, db_status_textbox]
        )

        fetch_db_btn = gr.Button("Fetch Database")
        fetch_db_btn.click(
            fn=update_patient_history,
            inputs=[],
            outputs=[db_status_textbox]
        )
        
    with gr.Tab("Database Upload and View"):
        gr.Markdown("### Store and Retrieve Context Information")

        db_display = gr.HTML()
        load_db_btn = gr.Button("Load Database Content")
        load_db_btn.click(display_db_data, outputs=db_display)

        # Buttons to clear databases
        clear_cataract_db_btn = gr.Button("Clear Cataract Database")
        clear_glaucoma_db_btn = gr.Button("Clear Glaucoma Database")

        clear_cataract_db_btn.click(
            fn=clear_database,
            inputs=[gr.State(value=db_path_cataract), gr.State(value="cataract_results")],
            outputs=db_display
        )

        clear_glaucoma_db_btn.click(
            fn=clear_database,
            inputs=[gr.State(value=db_path_glaucoma), gr.State(value="results")],
            outputs=db_display
        )
        
    demo.launch()