Upload 3 files

app.py

@@ -0,0 +1,328 @@
+import streamlit as st
+import plotly.graph_objects as go
+import plotly.express as px
+from ultralytics import YOLO
+import cv2
+import numpy as np
+from PIL import Image
+import pandas as pd
+from streamlit_lottie import st_lottie
+import requests
+
+# Set page configuration
+st.set_page_config(page_title="Advanced Dental Disease Detection", page_icon="🦷", layout="wide")
+
+# Enhanced CSS for better styling and image sizing
+st.markdown("""
+<style>
+    .main {
+        padding: 2rem;
+    }
+    .stAlert > div {
+        padding: 0.5rem;
+        border-radius: 0.5rem;
+    }
+    .upload-text {
+        font-size: 1.2rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+    .condition-section {
+        margin: 1rem 0;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        background-color: #f0f2f6;
+    }
+    .st-emotion-cache-1v0mbdj > img {
+        border-radius: 10px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        max-height: 400px;  /* Control maximum height of images */
+        object-fit: contain;
+    }
+    .cropped-image {
+        max-height: 250px;  /* Smaller height for cropped images */
+        width: auto;
+        margin: auto;
+    }
+    .st-tabs {
+        background-color: #ffffff;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05);
+    }
+    .detection-grid {
+        display: grid;
+        grid-template-columns: repeat(3, 1fr);
+        gap: 1rem;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def load_lottie_url(url: str):
+    """
+    Load Lottie animation from URL
+    Args:
+        url (str): URL of the Lottie animation
+    Returns:
+        dict: Lottie animation JSON data or None if failed to load
+    """
+    try:
+        r = requests.get(url)
+        if r.status_code != 200:
+            return None
+        return r.json()
+    except Exception as e:
+        st.error(f"Error loading Lottie animation: {str(e)}")
+        return None
+
+@st.cache_resource
+def load_model():
+    """Load the YOLO model"""
+    try:
+        model = YOLO('best.pt')
+        return model
+    except Exception as e:
+        st.error(f"Error loading model: {str(e)}")
+        return None
+
+def process_image(image, model):
+    """Process the image and return predictions"""
+    try:
+        if isinstance(image, Image.Image):
+            image_array = np.array(image)
+        else:
+            image_array = image
+
+        results = model.predict(image_array)
+        return results[0]
+    except Exception as e:
+        st.error(f"Error processing image: {str(e)}")
+        return None
+
+def draw_single_condition(image, box, class_name):
+    """Draw a single condition's bounding box on the image"""
+    try:
+        image_array = np.array(image).copy()
+        x1, y1, x2, y2 = map(int, box.xyxy[0])
+        cv2.rectangle(image_array, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        cv2.putText(image_array, class_name, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+        return Image.fromarray(image_array)
+    except Exception as e:
+        st.error(f"Error drawing single condition: {str(e)}")
+        return image
+
+def crop_detection(image, box):
+    """Crop the region of the detected condition"""
+    try:
+        image_array = np.array(image)
+        x1, y1, x2, y2 = map(int, box.xyxy[0])
+        padding_x, padding_y = int((x2 - x1) * 0.1), int((y2 - y1) * 0.1)
+        height, width = image_array.shape[:2]
+        x1, y1 = max(0, x1 - padding_x), max(0, y1 - padding_y)
+        x2, y2 = min(width, x2 + padding_x), min(height, y2 + padding_y)
+        cropped = image_array[y1:y2, x1:x2]
+        return Image.fromarray(cropped)
+    except Exception as e:
+        st.error(f"Error cropping detection: {str(e)}")
+        return None
+
+def draw_predictions(image, results):
+    """Draw all bounding boxes and labels on the image"""
+    try:
+        if isinstance(image, Image.Image):
+            image_array = np.array(image)
+        else:
+            image_array = image
+
+        plotted_image = results.plot()
+        return Image.fromarray(plotted_image)
+    except Exception as e:
+        st.error(f"Error drawing predictions: {str(e)}")
+        return image
+
+def group_predictions_by_condition(results):
+    """Group predictions by condition type"""
+    condition_groups = {}
+    if len(results.boxes) > 0:
+        for box in results.boxes:
+            class_id = int(box.cls[0])
+            class_name = results.names[class_id]
+            confidence = float(box.conf[0])
+            if class_name not in condition_groups:
+                condition_groups[class_name] = []
+            condition_groups[class_name].append({'box': box, 'confidence': confidence})
+    return condition_groups
+
+def create_confidence_chart(condition_groups):
+    data = []
+    for condition, detections in condition_groups.items():
+        for detection in detections:
+            data.append({
+                'Condition': condition,
+                'Confidence': detection['confidence']
+            })
+    df = pd.DataFrame(data)
+    fig = px.box(df, x='Condition', y='Confidence', points="all")
+    fig.update_layout(title_text='Confidence Distribution by Condition')
+    return fig
+
+def create_condition_count_chart(condition_groups):
+    counts = {condition: len(detections) for condition, detections in condition_groups.items()}
+    fig = go.Figure(data=[go.Pie(labels=list(counts.keys()), values=list(counts.values()))])
+    fig.update_layout(title_text='Distribution of Detected Conditions')
+    return fig
+
+def main():
+    # Header
+    st.title("🦷 Advanced Dental Disease Detection")
+    
+    # Sidebar
+    with st.sidebar:
+        st.title("About")
+        st.info(
+    """Welcome to DentalVision AI - Advanced X-ray Analysis
+
+Our application leverages YOLO11 technology to analyze dental X-rays and identify a comprehensive range of dental conditions and features:
+
+🦷 Common Dental Conditions
+- Cavities (Caries) and Tooth Decay
+- Fractured and Missing Teeth
+- Primary and Permanent Teeth
+- Tooth Attrition and Wear
+
+👨‍⚕️ Dental Treatments & Restorations
+- Crowns and Fillings
+- Dental Implants and Abutments
+- Root Canal Treatments
+- Post-cores and Gingival Formers
+
+🎯 Orthodontic Elements
+- Malaligned Teeth
+- Orthodontic Brackets and Wires
+- Permanent Retainers
+- TADs and Metal Bands
+
+🔍 Bone & Tissue Analysis
+- Mandibular Canal Assessment
+- Maxillary Sinus Evaluation
+- Bone Loss and Defects
+- Cyst Detection
+
+⚠️ Special Conditions
+- Impacted Teeth
+- Periapical Lesions
+- Retained Roots and Root Pieces
+- Root Resorption and Supra Eruption
+
+This AI-powered tool assists dental professionals in comprehensive X-ray analysis for more accurate diagnoses and treatment planning."""
+)
+        
+        # Add Lottie animation
+        #lottie_dental = load_lottie_url("https://assets5.lottiefiles.com/packages/lf20_xnbikipz.json")
+        #if lottie_dental:
+        #    st_lottie(lottie_dental, speed=1, height=200, key="dental")
+    
+    # Model loading
+    with st.spinner("Loading model..."):
+        model = load_model()
+
+    if model is None:
+        st.error("Failed to load model. Please check the model path and try again.")
+        return
+
+    # File uploader
+    uploaded_file = st.file_uploader("Choose an X-ray image...", type=['png', 'jpg', 'jpeg'])
+
+    if uploaded_file is not None:
+        try:
+            # Read image
+            image = Image.open(uploaded_file)
+            
+            # Make prediction
+            with st.spinner("Analyzing image..."):
+                results = process_image(image, model)
+
+            if results is not None:
+                # Display original and processed images side by side
+                st.header("Image Analysis")
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.subheader("Original Image")
+                    st.image(image, use_container_width=True)
+                
+                with col2:
+                    st.subheader("Detected Conditions")
+                    processed_image = draw_predictions(image, results)
+                    st.image(processed_image, use_container_width=True)
+
+                # Group predictions by condition
+                condition_groups = group_predictions_by_condition(results)
+
+                if condition_groups:
+                    st.header("Detailed Analysis by Condition")
+                    
+                    # Create tabs for each condition type
+                    tabs = st.tabs(list(condition_groups.keys()))
+                    
+                    for tab, (condition_name, detections) in zip(tabs, condition_groups.items()):
+                        with tab:
+                            st.subheader(f"{condition_name} Detections")
+                            st.write(f"Number of {condition_name} detected: {len(detections)}")
+                            
+                            # Display each instance of this condition
+                            for idx, detection in enumerate(detections, 1):
+                                st.write(f"#### Instance {idx}")
+                                st.write(f"Confidence: {detection['confidence']:.2%}")
+                                
+                                # Create three columns with controlled image sizes
+                                cols = st.columns(3)
+                                
+                                with cols[0]:
+                                    st.write("Full Image with Detection")
+                                    single_detection = draw_single_condition(image, detection['box'], condition_name)
+                                    st.image(single_detection, use_container_width=True, clamp=True)
+                                
+                                with cols[1]:
+                                    st.write("Cropped Region")
+                                    cropped_region = crop_detection(image, detection['box'])
+                                    if cropped_region is not None:
+                                        st.image(cropped_region, use_container_width=True, clamp=True)
+                                
+                                st.divider()
+                    
+                    # Add advanced visualizations
+                    st.header("Advanced Visualizations")
+                    viz_cols = st.columns(2)
+                    
+                    with viz_cols[0]:
+                        confidence_chart = create_confidence_chart(condition_groups)
+                        st.plotly_chart(confidence_chart, use_container_width=True)
+                    
+                    with viz_cols[1]:
+                        count_chart = create_condition_count_chart(condition_groups)
+                        st.plotly_chart(count_chart, use_container_width=True)
+                
+                else:
+                    st.info("No dental conditions detected in the image.")
+
+        except Exception as e:
+            st.error(f"Error processing image: {str(e)}")
+
+    # Additional information
+    with st.expander("ℹ️ How to use"):
+        st.markdown("""
+        1. Upload a dental X-ray image using the file uploader above
+        2. The model will automatically process the image
+        3. Results will show detected conditions with confidence scores
+        4. View detailed analysis for each condition type in separate tabs
+        5. For each detection you'll see:
+           - Full image with the detection marked
+           - Cropped view of the detected region
+           - Cropped view with detection marking
+        6. Explore advanced visualizations for a comprehensive overview
+        """)
+
+if __name__ == "__main__":
+    main()

best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af14905ab5bb9321e6ca55fa5e22bb66dc206f67d7610b9bbf8f38da8af46433
+size 367706701

requirements.txt

@@ -0,0 +1,9 @@
+streamlit
+plotly
+ultralytics
+opencv-python
+numpy
+pillow
+pandas
+streamlit-lottie
+requests