Spaces:

WellnessNexus
/

ThesisCataractLatest

Sleeping

App Files Files Community

ariankhalfani commited on Sep 14

Commit

7008805

•

1 Parent(s): acbef3a

Update app2.py

Browse files

Files changed (1) hide show

app2.py +91 -163

app2.py CHANGED Viewed

@@ -3,17 +3,26 @@ from ultralytics import YOLO
 import cv2
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
-import sqlite3
 import base64
 from io import BytesIO
 import tempfile
-import pandas as pd
 import os
 from pathlib import Path
 # Load YOLOv8 model
 model = YOLO("best.pt")
 def predict_image(input_image, name, age, medical_record, sex):
     if input_image is None:
         return None, "Please Input The Image"
@@ -55,6 +64,18 @@ def predict_image(input_image, name, age, medical_record, sex):
         # Draw the bounding box
         cv2.rectangle(image_with_boxes, (xmin, ymin), (xmax, ymax), color, 2)
         # Enlarge font scale and thickness
         font_scale = 1.0
@@ -77,6 +98,11 @@ def predict_image(input_image, name, age, medical_record, sex):
     # Add text and watermark
     pil_image_with_boxes = add_text_and_watermark(pil_image_with_boxes, name, age, medical_record, sex, label)
     return pil_image_with_boxes, raw_predictions_str
 # Function to add watermark
@@ -109,7 +135,7 @@ def add_text_and_watermark(image, name, age, medical_record, sex, label):
     draw = ImageDraw.Draw(image)
     # Load a larger font (adjust the size as needed)
-    font_size = 48  # Example font size
     try:
         font = ImageFont.truetype("font.ttf", size=font_size)
     except IOError:
@@ -139,110 +165,40 @@ def add_text_and_watermark(image, name, age, medical_record, sex, label):
     return image_with_watermark
-# Function to initialize the database
-def init_db():
-    conn = sqlite3.connect('results.db')
-    c = conn.cursor()
-    c.execute('''CREATE TABLE IF NOT EXISTS results
-                 (id INTEGER PRIMARY KEY, name TEXT, age INTEGER, medical_record INTEGER, sex TEXT, input_image BLOB, predicted_image BLOB, result TEXT)''')
-    conn.commit()
-    conn.close()
-# Function to submit result to the database
-def submit_result(name, age, medical_record, sex, input_image, predicted_image, result):
-    conn = sqlite3.connect('results.db')
-    c = conn.cursor()
-    input_image_np = np.array(input_image)
-    _, input_buffer = cv2.imencode('.png', cv2.cvtColor(input_image_np, cv2.COLOR_RGB2BGR))
-    input_image_bytes = input_buffer.tobytes()
-    predicted_image_np = np.array(predicted_image)
-    predicted_image_rgb = cv2.cvtColor(predicted_image_np, cv2.COLOR_RGB2BGR)  # Ensure correct color conversion
-    _, predicted_buffer = cv2.imencode('.png', predicted_image_rgb)
-    predicted_image_bytes = predicted_buffer.tobytes()
-    c.execute("INSERT INTO results (name, age, medical_record, sex, input_image, predicted_image, result) VALUES (?, ?, ?, ?, ?, ?, ?)",
-              (name, age, medical_record, sex, input_image_bytes, predicted_image_bytes, result))
-    conn.commit()
-    conn.close()
-    return "Result submitted to database."
-# Function to load and view database in HTML format
-def view_database():
-    conn = sqlite3.connect('results.db')
-    c = conn.cursor()
-    c.execute("SELECT name, age, medical_record, sex, input_image, predicted_image, result FROM results")
-    rows = c.fetchall()
-    conn.close()
-    # Prepare the HTML content
-    html_content = "<table border='1'><tr><th>Name</th><th>Age</th><th>Medical Record</th><th>Sex</th><th>Input Image</th><th>Predicted Image</th><th>Result</th></tr>"
-    for row in rows:
-        name, age, medical_record, sex, input_image_bytes, predicted_image_bytes, result = row
-        # Decode the images
-        input_image = Image.open(BytesIO(input_image_bytes))
-        predicted_image = Image.open(BytesIO(predicted_image_bytes))
-        # Convert images to base64 for display in HTML
-        buffered_input = BytesIO()
-        input_image.save(buffered_input, format="PNG")
-        input_image_base64 = base64.b64encode(buffered_input.getvalue()).decode('utf-8')
-        buffered_predicted = BytesIO()
-        predicted_image.save(buffered_predicted, format="PNG")
-        predicted_image_base64 = base64.b64encode(buffered_predicted.getvalue()).decode('utf-8')
-        # Add a row to the HTML table
-        html_content += f"<tr><td>{name}</td><td>{age}</td><td>{medical_record}</td><td>{sex}</td><td><img src='data:image/png;base64,{input_image_base64}' width='100'></td><td><img src='data:image/png;base64,{predicted_image_base64}' width='100'></td><td>{result}</td></tr>"
-    html_content += "</table>"
-    return html_content
-# Function to download database or HTML file
-def download_file(file_format):
-    directory = tempfile.gettempdir()
-    db_file_path = os.path.join(directory, 'results.db')
-    if file_format == "Database (.db)":
-        # Simulate creating or writing to the database file here
-        if not os.path.exists(db_file_path):
-            # Create a dummy database file for demonstration
-            conn = sqlite3.connect(db_file_path)
-            conn.execute('CREATE TABLE IF NOT EXISTS results (id INTEGER PRIMARY KEY, name TEXT)')
-            conn.commit()
-            conn.close()
-        return db_file_path
-    elif file_format == "HTML (.html)":
-        # Connect to the SQLite database
-        conn = sqlite3.connect(db_file_path)
-        try:
-            # Attempt to read the results table into a DataFrame
-            df = pd.read_sql_query("SELECT * FROM results", conn)
-        except pd.errors.DatabaseError as e:
-            conn.close()
-            raise ValueError("Table 'results' does not exist in the database.") from e
-        # Close the database connection
-        conn.close()
-        # Define the path for the HTML file
-        html_file_path = os.path.join(directory, "results.html")
-        # Save the DataFrame as an HTML file
-        df.to_html(html_file_path, index=False)
-        return html_file_path
-    else:
-        raise ValueError("Invalid file format specified.")
-# Initialize the database
-init_db()
 # Gradio Interface
 def interface(name, age, medical_record, sex, input_image):
@@ -250,65 +206,37 @@ def interface(name, age, medical_record, sex, input_image):
         return None, "Please upload an image.", None
     output_image, raw_result = predict_image(input_image, name, age, medical_record, sex)
-    submit_status = submit_result(name, age, medical_record, sex, input_image, output_image, raw_result)
-    return output_image, raw_result, submit_status
-# View Database Function (Updated)
-def view_db_interface():
-    html_content = view_database()
-    return html_content
-# Download Function
-def download_interface(choice):
-    try:
-        # Get the file path
-        file_path = download_file(choice)
-        # Return the file path (string) directly for the Gradio component to handle
-        return file_path
-    except (FileNotFoundError, ValueError) as e:
-        # Display error message in Gradio output
-        return str(e)
-# Gradio Blocks
-with gr.Blocks() as demo:
-    with gr.Column():
-        gr.Markdown("# Cataract Detection System")
-        gr.Markdown("Upload an image to detect cataract and add patient details.")
-        gr.Markdown("This application uses YOLOv8 with mAP=0.981")
-    with gr.Column():
-        name = gr.Textbox(label="Name")
-        age = gr.Number(label="Age")
-        medical_record = gr.Number(label="Medical Record")
-        sex = gr.Radio(["Male", "Female"], label="Sex")
-        input_image = gr.Image(type="pil", label="Upload an Image", image_mode="RGB")
-    with gr.Column():
-        submit_btn = gr.Button("Submit")
-        output_image = gr.Image(type="pil", label="Predicted Image")
-    with gr.Row():
-        raw_result = gr.Textbox(label="Raw Result", lines=5)
-        submit_status = gr.Textbox(label="Submission Status")
-    submit_btn.click(fn=interface, inputs=[name, age, medical_record, sex, input_image], outputs=[output_image, raw_result, submit_status])
-    with gr.Column():
-        view_db_btn = gr.Button("View Database")
-        db_output = gr.HTML(label="Database Records")
-    view_db_btn.click(fn=view_db_interface, inputs=[], outputs=[db_output])
-    with gr.Column():
-        download_choice = gr.Radio(["Database (.db)", "Database (.html)"], label="Choose the file to download:")
-        download_btn_db = gr.Button("Download Database (.db)")
-        download_btn_html = gr.Button("Download HTML (.html)")
-        download_file_output = gr.File(label="Download File")
-    download_btn_db.click(lambda: download_file("Database (.db)"), outputs=download_file_output)
-    download_btn_html.click(lambda: download_file("HTML (.html)"), outputs=download_file_output)
-# Launch the Gradio app
-demo.launch()

 import cv2
 import numpy as np
 from PIL import Image, ImageDraw, ImageFont
 import base64
 from io import BytesIO
 import tempfile
 import os
 from pathlib import Path
+import shutil
 # Load YOLOv8 model
 model = YOLO("best.pt")
+# Create directories if not present
+uploaded_folder = Path('Uploaded_Picture')
+predicted_folder = Path('Predicted_Picture')
+uploaded_folder.mkdir(parents=True, exist_ok=True)
+predicted_folder.mkdir(parents=True, exist_ok=True)
+# Path to store accumulated HTML data
+html_file_path = Path(tempfile.gettempdir()) / 'patient_data.html'
+# Function to predict image and add bounding box, text, circle, and watermark
 def predict_image(input_image, name, age, medical_record, sex):
     if input_image is None:
         return None, "Please Input The Image"
         # Draw the bounding box
         cv2.rectangle(image_with_boxes, (xmin, ymin), (xmax, ymax), color, 2)
+        # Calculate the center of the bounding box
+        center_x = (xmin + xmax) // 2
+        center_y = (ymin + ymax) // 2
+        # Calculate the radius (1/12 of the average of the width and height of the bounding box)
+        box_width = xmax - xmin
+        box_height = ymax - ymin
+        radius = int((box_width + box_height) / 24)  # Average of width and height divided by 12
+        # Draw a white circle at the center of the bounding box
+        cv2.circle(image_with_boxes, (center_x, center_y), radius, (255, 255, 255), thickness=2)
         # Enlarge font scale and thickness
         font_scale = 1.0
     # Add text and watermark
     pil_image_with_boxes = add_text_and_watermark(pil_image_with_boxes, name, age, medical_record, sex, label)
+    # Save images to directories
+    image_name = f"{name}-{age}-{sex}-{medical_record}.png"
+    input_image.save(uploaded_folder / image_name)
+    pil_image_with_boxes.save(predicted_folder / image_name)
     return pil_image_with_boxes, raw_predictions_str
 # Function to add watermark
     draw = ImageDraw.Draw(image)
     # Load a larger font (adjust the size as needed)
+    font_size = 24  # Example font size
     try:
         font = ImageFont.truetype("font.ttf", size=font_size)
     except IOError:
     return image_with_watermark
+# Function to save patient info in HTML and accumulate data
+def save_patient_info_to_html(name, age, medical_record, sex, result):
+    html_content = f"""
+    <html>
+        <body>
+            <h1>Patient Information</h1>
+            <p><strong>Name:</strong> {name}</p>
+            <p><strong>Age:</strong> {age}</p>
+            <p><strong>Medical Record:</strong> {medical_record}</p>
+            <p><strong>Sex:</strong> {sex}</p>
+            <p><strong>Result:</strong> {result}</p>
+            <hr>
+        </body>
+    </html>
+    """
+    # Check if the HTML file already exists
+    if html_file_path.exists():
+        with open(html_file_path, 'a') as f:
+            f.write(html_content)
+    else:
+        with open(html_file_path, 'w') as f:
+            f.write(html_content)
+    return str(html_file_path)
+# Function to download the folders
+def download_folder(folder):
+    zip_path = os.path.join(tempfile.gettempdir(), f"{folder}.zip")
+    # Zip the folder
+    shutil.make_archive(zip_path.replace('.zip', ''), 'zip', folder)
+    return zip_path
 # Gradio Interface
 def interface(name, age, medical_record, sex, input_image):
         return None, "Please upload an image.", None
     output_image, raw_result = predict_image(input_image, name, age, medical_record, sex)
+    if output_image is None:
+        return None, raw_result, None
+    # Save patient info to HTML
+    html_file_path = save_patient_info_to_html(name, age, medical_record, sex, raw_result)
+    # Encode the image to display in Gradio
+    buffered = BytesIO()
+    output_image.save(buffered, format="PNG")
+    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    # Provide the zip file path for download
+    zip_file = download_folder(predicted_folder)
+    return f'<img src="data:image/png;base64,{img_str}" alt="Processed Image"/>', raw_result, zip_file
+# Define Gradio interface
+gr.Interface(
+    fn=interface,
+    inputs=[
+        gr.Textbox(label="Name"),
+        gr.Textbox(label="Age"),
+        gr.Textbox(label="Medical Record"),
+        gr.Dropdown(label="Sex", choices=["Male", "Female", "Other"]),
+        gr.Image(source="upload", tool="editor", label="Upload an Image")
+    ],
+    outputs=[
+        gr.HTML(label="Processed Image"),
+        gr.Textbox(label="Raw Predictions"),
+        gr.File(label="Download ZIP")
+    ],
+    title="Patient Image Analysis"
+).launch()