First Upload

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,38 @@
+venv
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+*.log
+*.tmp
+*.swp
+*.swo
+*.DS_Store
+__pycache__/
+.Python
+env/
+env.bak/
+.env
+.venv/
+build/
+dist/
+*.egg-info/
+.idea/
+.vscode/
+.mypy_cache/
+.pytest_cache/
+htmlcov/
+coverage.xml
+*.cover
+*.coverage
+*.cov
+*.egg
+*.manifest
+*.spec
+profile_default/
+ipython_config.py
+.cache/
+*.png
+*.jpg
+*.jpeg
+models/*.keras

Dockerfile

@@ -1,20 +1,46 @@
-FROM python:3.13.5-slim
+# Hugging Face Spaces - Dockerized Streamlit app
+FROM python:3.10-slim
 
+# Prevent Python from writing .pyc files and enable unbuffered logs
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# Workdir
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
+# System deps (opencv, fonts, image libs, etc.)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        build-essential \
+        git \
+        ffmpeg \
+        libsm6 \
+        libxext6 \
+        libglib2.0-0 \
+        libgl1-mesa-glx \
+        libgtk2.0-dev \
+        libgtk-3-dev \
+        ca-certificates \
     && rm -rf /var/lib/apt/lists/*
 
+# Copy dependency list first (better layer caching)
 COPY requirements.txt ./
-COPY src/ ./src/
 
-RUN pip3 install -r requirements.txt
+# Install Python deps
+RUN pip install --upgrade pip && \
+    pip install -r requirements.txt
+
+# Copy app source
+COPY . .
 
-EXPOSE 8501
+# Streamlit configuration for Spaces
+ENV PORT=7860 \
+    STREAMLIT_SERVER_PORT=7860 \
+    STREAMLIT_SERVER_HEADLESS=true \
+    STREAMLIT_SERVER_ADDRESS=0.0.0.0
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+EXPOSE 7860
 
-ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# Entrypoint - run Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,19 +0,0 @@
----
-title: PathoAI
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).

app.py

@@ -0,0 +1,324 @@
+import streamlit as st
+import cv2
+import numpy as np
+import time
+import traceback
+import os
+import requests
+from core.config import Config
+from core.inference import InferenceEngine
+from core.image_processing import ImageProcessor
+from ui.dashboard import (
+    render_css, 
+    render_header, 
+    render_classification_panel,
+    render_segmentation_panel
+)
+
+# Model indirme linkleri (Pixeldrain)
+MODEL_URLS = {
+    "resnet50_best.keras": {
+        "url": "https://pixeldrain.com/api/file/Pn9gpTnb?download",
+        "description": "ResNet50 Siniflandirici",
+        "size_mb": 212
+    },
+    "cia_net_final_sota.keras": {
+        "url": "https://pixeldrain.com/api/file/BpPXq8Kw?download",
+        "description": "CIA-Net Segmentasyon",
+        "size_mb": 150
+    }
+}
+
+def format_size(bytes_size):
+    """Byte boyutunu okunabilir formata cevir."""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if bytes_size < 1024:
+            return f"{bytes_size:.1f} {unit}"
+        bytes_size /= 1024
+    return f"{bytes_size:.1f} TB"
+
+def download_model_with_progress(model_name, url, save_path, progress_bar, status_container):
+    """Model dosyasini progress bar ile indir."""
+    try:
+        # Baslangic istegi
+        response = requests.get(url, stream=True, timeout=30)
+        response.raise_for_status()
+        
+        total_size = int(response.headers.get('content-length', 0))
+        downloaded = 0
+        chunk_size = 1024 * 1024  # 1MB chunks
+        
+        # Gecici dosyaya yaz
+        temp_path = save_path + ".tmp"
+        
+        with open(temp_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=chunk_size):
+                if chunk:
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    
+                    # Progress guncelle
+                    if total_size > 0:
+                        progress = downloaded / total_size
+                        progress_bar.progress(progress)
+                        status_container.markdown(
+                            f"**{model_name}** indiriliyor... "
+                            f"`{format_size(downloaded)}` / `{format_size(total_size)}` "
+                            f"({progress*100:.1f}%)"
+                        )
+        
+        # Basarili indirme sonrasi dosyayi tasi
+        os.rename(temp_path, save_path)
+        return True
+        
+    except requests.exceptions.Timeout:
+        status_container.error("Baglanti zaman asimina ugradi. Tekrar deneyin.")
+        return False
+    except requests.exceptions.ConnectionError:
+        status_container.error("Internet baglantisi bulunamadi.")
+        return False
+    except Exception as e:
+        status_container.error(f"Indirme hatasi: {str(e)}")
+        # Gecici dosyayi temizle
+        temp_path = save_path + ".tmp"
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+        return False
+
+def check_and_download_models():
+    """Model dosyalarini kontrol et ve eksikleri indir."""
+    os.makedirs(Config.MODEL_DIR, exist_ok=True)
+    
+    missing_models = []
+    
+    if not os.path.exists(Config.CLS_MODEL_PATH):
+        missing_models.append(("resnet50_best.keras", Config.CLS_MODEL_PATH))
+    if not os.path.exists(Config.SEG_MODEL_PATH):
+        missing_models.append(("cia_net_final_sota.keras", Config.SEG_MODEL_PATH))
+    
+    if not missing_models:
+        return True
+    
+    # Indirme arayuzu
+    st.markdown("---")
+    st.subheader("Model Dosyalari Eksik")
+    
+    # Eksik modelleri listele
+    total_size = 0
+    for model_name, _ in missing_models:
+        info = MODEL_URLS.get(model_name, {})
+        size = info.get("size_mb", 0)
+        desc = info.get("description", model_name)
+        total_size += size
+        st.markdown(f"- **{desc}** (`{model_name}`) - ~{size} MB")
+    
+    st.info(f"Toplam indirme boyutu: ~{total_size} MB")
+    
+    # Indirme butonu
+    if st.button("Modelleri Indir", type="primary"):
+        for i, (model_name, save_path) in enumerate(missing_models):
+            info = MODEL_URLS.get(model_name, {})
+            url = info.get("url", "")
+            desc = info.get("description", model_name)
+            
+            st.markdown(f"### {i+1}/{len(missing_models)}: {desc}")
+            
+            progress_bar = st.progress(0)
+            status_container = st.empty()
+            
+            success = download_model_with_progress(
+                model_name, url, save_path, progress_bar, status_container
+            )
+            
+            if success:
+                status_container.success(f"{desc} basariyla indirildi!")
+            else:
+                st.error("Indirme basarisiz. Sayfa yenilenerek tekrar deneyin.")
+                return False
+        
+        st.success("Tum modeller indirildi! Sayfa yenileniyor...")
+        time.sleep(2)
+        st.rerun()
+    
+    return False
+
+def main():
+    render_css()
+    
+    # Model dosyalarini kontrol et ve gerekirse indir
+    if not check_and_download_models():
+        st.error("Model dosyalari yuklenemedi. Lutfen internet baglantinizi kontrol edin.")
+        st.stop()
+    
+    with st.sidebar:
+        st.title("Kontrol Paneli")
+        st.info("Sistem: PathoAI\nVersiyon: 1.0.0")
+        st.markdown("### Analiz Ayarları")
+        use_norm = st.toggle("Stain Normalization", value=True)
+        st.markdown("---")
+        st.write("© 2026 PathoAI - Tüm Hakları Saklıdır")
+
+    render_header(Config.APP_NAME, "2.1.0")
+    
+    engine = InferenceEngine()
+    uploaded_file = st.file_uploader("Analiz edilecek histopatoloji görüntüsünü yükleyin", type=['png', 'jpg', 'jpeg', 'tif'])
+    
+    if uploaded_file:
+        with st.spinner("Yapay Zeka Motorları Yükleniyor..."):
+            if not engine.load_models():
+                st.error("Model dosyaları yüklenemedi.")
+                st.stop()
+        
+        file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
+        img_bgr = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR)
+        img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+        
+        if st.button("Analizi Başlat", type="primary"):
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+            log_container = st.expander("Detaylı İşlem Logları", expanded=False)
+            
+            try:
+                start_time = time.perf_counter()
+                
+                with log_container:
+                    st.write("**Analiz başlatıldı...**")
+                    st.write(f"Görüntü boyutu: {img_rgb.shape[1]}x{img_rgb.shape[0]} piksel")
+                
+                # Ön işleme
+                t_pre_start = time.perf_counter()
+                status_text.text("Ön işleme yapılıyor...")
+                progress_bar.progress(10)
+                
+                if use_norm:
+                    with log_container:
+                        st.write("Macenko stain normalization uygulanıyor...")
+                    proc_img = ImageProcessor.macenko_normalize(img_rgb)
+                    with log_container:
+                        st.write("Renk normalizasyonu tamamlandı")
+                else:
+                    proc_img = img_rgb
+                    with log_container:
+                        st.write("Normalizasyon atlandı (ham görüntü kullanılıyor)")
+                
+                t_pre_end = time.perf_counter()
+                with log_container:
+                    st.write(f"Ön işleme süresi: **{(t_pre_end - t_pre_start):.3f} s**")
+                progress_bar.progress(20)
+                
+                # Sınıflandırma
+                t_cls_start = time.perf_counter()
+                status_text.text("ResNet50 ile doku sınıflandırması yapılıyor...")
+                
+                with log_container:
+                    st.write("**ResNet50 Classifier çalışıyor...**")
+                
+                c_idx, cls_conf, tensor = engine.predict_classification(proc_img)
+                
+                t_cls_end = time.perf_counter()
+                with log_container:
+                    st.write(f"Tanı: **{Config.CLASSES[c_idx]}**")
+                    st.write(f"Güven skoru: **%{cls_conf*100:.2f}**")
+                    st.write(f"Sınıflandırma süresi: **{(t_cls_end - t_cls_start):.3f} s**")
+                
+                progress_bar.progress(40)
+                
+                # Grad-CAM
+                t_cam_start = time.perf_counter()
+                status_text.text("Grad-CAM aktivasyon haritası oluşturuluyor...")
+                
+                with log_container:
+                    st.write("**Grad-CAM XAI analizi başlatılıyor...**")
+                
+                heatmap = engine.generate_gradcam(tensor, c_idx)
+                
+                t_cam_end = time.perf_counter()
+                with log_container:
+                    if np.max(heatmap) > 0:
+                        st.write("Grad-CAM başarıyla oluşturuldu")
+                    else:
+                        st.warning("Grad-CAM oluşturulamadı (boş heatmap)")
+                    st.write(f"Grad-CAM süresi: **{(t_cam_end - t_cam_start):.3f} s**")
+                
+                progress_bar.progress(60)
+                
+                # Segmentasyon
+                t_seg_start = time.perf_counter()
+                status_text.text("CIA-Net ile hücre segmentasyonu yapılıyor...")
+                
+                with log_container:
+                    st.write("**CIA-Net Segmenter çalışıyor...**")
+                
+                nuc_map, con_map, seg_conf = engine.predict_segmentation(proc_img)
+                
+                t_seg_end = time.perf_counter()
+                with log_container:
+                    st.write(f"Nükleus haritası oluşturuldu")
+                    st.write(f"Segmentasyon güveni: **%{seg_conf*100:.2f}**")
+                    st.write(f"Segmentasyon süresi: **{(t_seg_end - t_seg_start):.3f} s**")
+                
+                progress_bar.progress(75)
+                
+                # Post-processing
+                t_post_start = time.perf_counter()
+                status_text.text("Hücre ayrıştırma ve morfolojik analiz...")
+                with log_container:
+                    st.write("**Watershed algoritması uygulanıyor...**")
+                
+                mask = ImageProcessor.adaptive_watershed(nuc_map, con_map)
+                
+                t_watershed_end = time.perf_counter()
+                with log_container:
+                    unique_cells = len(np.unique(mask)) - 1
+                    st.write(f"Tespit edilen hücre sayısı: **{unique_cells}**")
+                    st.write(f"Watershed/post-processing süresi: **{(t_watershed_end - t_post_start):.3f} s**")
+                
+                progress_bar.progress(85)
+                
+                with log_container:
+                    st.write("**Belirsizlik (entropy) hesaplanıyor...**")
+                
+                entropy = ImageProcessor.calculate_entropy(nuc_map)
+                
+                t_entropy_end = time.perf_counter()
+                with log_container:
+                    st.write(f"Ortalama entropi: **{np.mean(entropy):.3f}**")
+                    st.write(f"Entropi hesaplama süresi: **{(t_entropy_end - t_watershed_end):.3f} s**")
+                
+                progress_bar.progress(90)
+                
+                with log_container:
+                    st.write("**Morfometrik özellikler çıkarılıyor...**")
+                
+                stats = ImageProcessor.calculate_morphometrics(mask)
+                
+                t_morph_end = time.perf_counter()
+                with log_container:
+                    if not stats.empty:
+                        st.write(f"{len(stats)} hücre için morfoloji hesaplandı")
+                        st.write(f"  - Ortalama alan: {stats['Area'].mean():.1f} px²")
+                        st.write(f"  - Ortalama dairesellik: {stats['Circularity'].mean():.3f}")
+                    else:
+                        st.warning("Hücre tespit edilemedi")
+                    st.write(f"Morfometrik analiz süresi: **{(t_morph_end - t_entropy_end):.3f} s**")
+                
+                progress_bar.progress(100)
+                
+                elapsed = time.perf_counter() - start_time
+                
+                with log_container:
+                    st.success(f"**Analiz tamamlandı!** (Süre: {elapsed:.2f} saniye)")
+                
+                status_text.empty()
+                
+                # Sonuçları göster
+                render_classification_panel(img_rgb, Config.CLASSES[c_idx], cls_conf, seg_conf, heatmap)
+                render_segmentation_panel(img_rgb, nuc_map, entropy, mask, stats)
+                
+            except Exception as e:
+                st.error(f"Hata: {e}")
+                with log_container:
+                    st.code(traceback.format_exc())
+
+if __name__ == "__main__":
+    main()

core/config.py

@@ -0,0 +1,27 @@
+import os
+
+class Config:
+    """Central Configuration Management"""
+    APP_NAME = "PathoAI"
+    VERSION = "v1.0.0"
+    
+    # Image Parameters
+    IMG_SIZE = (224, 224)
+    INPUT_SHAPE = (224, 224, 3)
+    
+    # Class Definitions
+    CLASSES = [
+        'Benign (Normal Doku)', 
+        'Adenocarcinoma (Akciğer Kanseri Tip 1)', 
+        'Squamous Cell Carcinoma (Akciğer Kanseri Tip 2)'
+    ]
+    
+    # File Paths
+    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    MODEL_DIR = os.path.join(BASE_DIR, "models")
+    CLS_MODEL_PATH = os.path.join(MODEL_DIR, "resnet50_best.keras")
+    SEG_MODEL_PATH = os.path.join(MODEL_DIR, "cia_net_final_sota.keras")
+    
+    # Thresholds
+    NUC_THRESHOLD = 0.4  # Nucleus detection sensitivity
+    CON_THRESHOLD = 0.3  # Contour detection sensitivity

core/image_processing.py

@@ -0,0 +1,94 @@
+import numpy as np
+import cv2
+import pandas as pd
+from scipy import ndimage as ndi
+from skimage.segmentation import watershed
+from skimage.feature import peak_local_max
+from skimage.measure import label, regionprops
+from .config import Config
+
+class ImageProcessor:
+    @staticmethod
+    def macenko_normalize(img, Io=240, alpha=1, beta=0.15):
+        """Normalizes H&E staining appearance."""
+        try:
+            HER = np.array([[0.650, 0.704, 0.286], [0.072, 0.990, 0.105], [0.268, 0.570, 0.776]])
+            h, w, c = img.shape
+            img_flat = img.reshape((-1, 3))
+            OD = -np.log((img_flat.astype(float) + 1) / Io)
+            
+            ODhat = OD[np.all(OD > beta, axis=1)]
+            if len(ODhat) < 10: return img
+            
+            eigvals, eigvecs = np.linalg.eigh(np.cov(ODhat.T))
+            That = ODhat.dot(eigvecs[:, 1:3])
+            phi = np.arctan2(That[:, 1], That[:, 0])
+            minPhi = np.percentile(phi, alpha)
+            maxPhi = np.percentile(phi, 100 - alpha)
+            
+            vMin = eigvecs[:, 1:3].dot(np.array([(np.cos(minPhi), np.sin(minPhi))]).T)
+            vMax = eigvecs[:, 1:3].dot(np.array([(np.cos(maxPhi), np.sin(maxPhi))]).T)
+            
+            if vMin[0] > vMax[0]: HE = np.array((vMin[:, 0], vMax[:, 0])).T
+            else: HE = np.array((vMax[:, 0], vMin[:, 0])).T
+            
+            Y = np.reshape(OD, (-1, 3)).T
+            C = np.linalg.lstsq(HE, Y, rcond=None)[0]
+            maxC = np.array([1.9705, 1.0308])
+            
+            Inorm = Io * np.exp(-np.dot(HER[:, 0:2], (C/maxC * maxC)[:, np.newaxis]))
+            return np.clip(np.reshape(Inorm.T, (h, w, c)), 0, 255).astype(np.uint8)
+        except:
+            return img
+
+    @staticmethod
+    def adaptive_watershed(pred_nuc, pred_con):
+        """Separates touching cells using probability topography."""
+        nuc_mask = (pred_nuc > Config.NUC_THRESHOLD).astype(np.uint8)
+        con_mask = (pred_con > Config.CON_THRESHOLD).astype(np.uint8)
+        
+        # Create markers from nucleus minus contour
+        markers_raw = np.clip(nuc_mask - con_mask, 0, 1)
+        kernel = np.ones((3,3), np.uint8)
+        markers_clean = cv2.morphologyEx(markers_raw, cv2.MORPH_OPEN, kernel, iterations=1)
+        
+        # Find peaks
+        distance = ndi.distance_transform_edt(markers_clean)
+        coords = peak_local_max(distance, footprint=np.ones((5, 5)), labels=markers_clean, min_distance=5)
+        mask = np.zeros(distance.shape, dtype=bool)
+        mask[tuple(coords.T)] = True
+        markers, _ = ndi.label(mask)
+        
+        # Expand markers
+        return watershed(-distance, markers, mask=nuc_mask)
+
+    @staticmethod
+    def calculate_morphometrics(label_mask):
+        """Calculates biological features for each cell."""
+        regions = regionprops(label_mask)
+        stats = []
+        for prop in regions:
+            area = prop.area
+            if area < 30: continue # Noise filter
+            perimeter = prop.perimeter
+            if perimeter == 0: continue
+            
+            # Metric calculations
+            circularity = (4 * np.pi * area) / (perimeter ** 2)
+            aspect_ratio = prop.major_axis_length / (prop.minor_axis_length + 1e-5)
+            
+            stats.append({
+                'Area': area,
+                'Perimeter': int(perimeter),
+                'Circularity': round(circularity, 3),
+                'Solidity': round(prop.solidity, 3),
+                'Aspect_Ratio': round(aspect_ratio, 2)
+            })
+        return pd.DataFrame(stats)
+    
+    @staticmethod
+    def calculate_entropy(prob_map):
+        """Calculates Shannon Entropy (Uncertainty Map)."""
+        prob_map = np.clip(prob_map, 1e-7, 1-1e-7)
+        entropy = - (prob_map * np.log(prob_map) + (1-prob_map) * np.log(1-prob_map))
+        return entropy

core/inference.py

@@ -0,0 +1,327 @@
+import os
+import logging
+os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"
+
+import tensorflow as tf
+tf.get_logger().setLevel(logging.ERROR)
+
+import numpy as np
+import cv2
+from tensorflow.keras import models
+from .config import Config
+
+# --- CUSTOM OBJECTS ---
+@tf.keras.utils.register_keras_serializable()
+class SmoothTruncatedLoss(tf.keras.losses.Loss):
+    def __init__(self, gamma=0.2, name="smooth_truncated_loss", **kwargs):
+        super().__init__(name=name, **kwargs)
+        self.gamma = gamma
+    def call(self, y_true, y_pred):
+        y_true = tf.cast(y_true, tf.float32)
+        y_pred = tf.cast(y_pred, tf.float32)
+        y_pred = tf.clip_by_value(y_pred, 1e-7, 1.0 - 1e-7)
+        pt = tf.where(tf.equal(y_true, 1), y_pred, 1 - y_pred)
+        loss_outlier = -tf.math.log(self.gamma) + 0.5 * (1 - (pt**2)/(self.gamma**2))
+        loss_inlier = -tf.math.log(pt)
+        return tf.reduce_mean(tf.where(pt < self.gamma, loss_outlier, loss_inlier))
+    def get_config(self):
+        config = super().get_config()
+        config.update({"gamma": self.gamma})
+        return config
+
+def soft_dice_loss(y_true, y_pred): return 1.0
+def dice_coef(y_true, y_pred): return 1.0
+
+class InferenceEngine:
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(InferenceEngine, cls).__new__(cls)
+            cls._instance.classifier = None
+            cls._instance.segmenter = None
+        return cls._instance
+
+    def load_models(self):
+        if self.classifier is not None and self.segmenter is not None:
+            return True
+            
+        print(f"Loading models from: {Config.MODEL_DIR}")
+        
+        try:
+            if not os.path.exists(Config.CLS_MODEL_PATH): return False
+            self.classifier = tf.keras.models.load_model(Config.CLS_MODEL_PATH, compile=False)
+            
+            if not os.path.exists(Config.SEG_MODEL_PATH): return False
+            custom_objects = {
+                'SmoothTruncatedLoss': SmoothTruncatedLoss,
+                'soft_dice_loss': soft_dice_loss, 
+                'dice_coef': dice_coef
+            }
+            self.segmenter = tf.keras.models.load_model(Config.SEG_MODEL_PATH, custom_objects=custom_objects, compile=False)
+            
+            return True
+        except Exception as e:
+            print(f"Model Load Error: {e}")
+            return False
+
+    def predict_classification(self, img):
+        if self.classifier is None: raise RuntimeError("Classifier not loaded!")
+        img_resized = cv2.resize(img, Config.IMG_SIZE)
+        img_tensor = np.expand_dims(img_resized.astype(np.float32) / 255.0, axis=0)
+        preds = self.classifier.predict(img_tensor, verbose=0)
+        return np.argmax(preds), np.max(preds), img_tensor
+
+    def predict_segmentation(self, img):
+        if self.segmenter is None: raise RuntimeError("Segmenter not loaded!")
+        
+        # --- BOYUT HATASI İÇİN DÜZELTME ---
+        # Model sabit 224x224 giriş bekliyor.
+        # Görüntüyü ne olursa olsun 224x224 yapıyoruz.
+        h_orig, w_orig, _ = img.shape
+        
+        img_resized = cv2.resize(img, (224, 224))
+        img_tensor = np.expand_dims(img_resized.astype(np.float32) / 255.0, axis=0)
+        
+        preds = self.segmenter.predict(img_tensor, verbose=0)
+        
+        # Çıktıları al (Nuclei ve Contour)
+        nuc_prob = preds[0][0, :, :, 0]
+        con_prob = preds[1][0, :, :, 0]
+        
+        # Segmentasyon Güven Skoru
+        # Sadece hücre olduğunu düşündüğü (>0.5) piksellerin ortalamasını al
+        mask_indices = nuc_prob > 0.5
+        if np.any(mask_indices):
+            seg_confidence = np.mean(nuc_prob[mask_indices])
+        else:
+            seg_confidence = 0.0
+        
+        # Çıktıyı orijinal boyuta geri büyüt (Görselleştirme için)
+        nuc_final = cv2.resize(nuc_prob, (w_orig, h_orig))
+        con_final = cv2.resize(con_prob, (w_orig, h_orig))
+        
+        return nuc_final, con_final, seg_confidence
+
+    def _find_target_layer(self):
+        # ResNet50'nin bilinen son conv katmanını ara
+        for layer in self.classifier.layers:
+            if 'resnet50' in layer.name: # Nested model varsa
+                try:
+                    return layer.get_layer('conv5_block3_out').output, layer.output
+                except:
+                    pass
+        # Düz modelse
+        try:
+            return self.classifier.get_layer('conv5_block3_out').output, self.classifier.output
+        except:
+            return None, None
+
+    def generate_gradcam(self, img_tensor, class_idx):
+        """Generate Grad-CAM heatmap - Keras 3 compatible version for nested ResNet50."""
+        if self.classifier is None: 
+            return np.zeros((224, 224))
+        
+        try:
+            print("Grad-CAM baslatiliyor...")
+            
+            # Model yapısını analiz et
+            print(f"Model katman sayisi: {len(self.classifier.layers)}")
+            
+            # ResNet50 base modelini bul (nested model olarak)
+            base_model = None
+            base_model_layer_idx = None
+            for idx, layer in enumerate(self.classifier.layers):
+                if 'resnet' in layer.name.lower():
+                    base_model = layer
+                    base_model_layer_idx = idx
+                    print(f"Base model bulundu: {layer.name} (index: {idx})")
+                    break
+            
+            if base_model is not None:
+                # Nested model yapısı - ResNet50 bir Functional model olarak içeride
+                print("Nested model yapisi tespit edildi")
+                
+                # ResNet50'nin son conv katmanını bul
+                try:
+                    last_conv_layer = base_model.get_layer('conv5_block3_out')
+                    print(f"Son conv katmani: conv5_block3_out")
+                except Exception as e:
+                    print(f"conv5_block3_out bulunamadi: {e}")
+                    return self._activation_based_cam(img_tensor)
+                
+                # Yöntem: GradientTape ile manuel hesaplama
+                img_tf = tf.convert_to_tensor(img_tensor, dtype=tf.float32)
+                
+                # Feature extractor model - sadece conv output için
+                feature_extractor = tf.keras.Model(
+                    inputs=base_model.input,
+                    outputs=last_conv_layer.output
+                )
+                
+                print("Gradient hesaplaniyor (nested model)...")
+                
+                with tf.GradientTape(persistent=True) as tape:
+                    tape.watch(img_tf)
+                    
+                    # ResNet50'den feature map al
+                    conv_output = feature_extractor(img_tf, training=False)
+                    tape.watch(conv_output)
+                    
+                    # Tam model prediction
+                    predictions = self.classifier(img_tf, training=False)
+                    
+                    # Hedef sınıf skoru
+                    if class_idx < predictions.shape[-1]:
+                        class_score = predictions[0, class_idx]
+                    else:
+                        class_score = predictions[0, 0]
+                    
+                    print(f"Class score: {class_score.numpy():.4f}")
+                
+                # Gradient hesapla
+                grads = tape.gradient(class_score, conv_output)
+                del tape
+                
+                if grads is None:
+                    print("Gradient None - activation based CAM deneniyor...")
+                    return self._activation_based_cam(img_tensor)
+                
+                print(f"Gradient shape: {grads.shape}")
+                
+            else:
+                # Düz model yapısı
+                print("Duz model yapisi - dogrudan katman aranacak")
+                
+                # conv5_block3_out veya son Conv2D katmanını bul
+                last_conv_layer = None
+                try:
+                    last_conv_layer = self.classifier.get_layer('conv5_block3_out')
+                except:
+                    for layer in reversed(self.classifier.layers):
+                        if isinstance(layer, tf.keras.layers.Conv2D):
+                            last_conv_layer = layer
+                            break
+                
+                if last_conv_layer is None:
+                    print("Conv katmani bulunamadi")
+                    return self._activation_based_cam(img_tensor)
+                
+                print(f"Son conv katmani: {last_conv_layer.name}")
+                
+                # Grad model oluştur
+                grad_model = tf.keras.Model(
+                    inputs=self.classifier.input,
+                    outputs=[last_conv_layer.output, self.classifier.output]
+                )
+                
+                img_tf = tf.convert_to_tensor(img_tensor, dtype=tf.float32)
+                
+                print("Gradient hesaplaniyor (duz model)...")
+                
+                with tf.GradientTape() as tape:
+                    conv_output, predictions = grad_model(img_tf, training=False)
+                    
+                    if class_idx < predictions.shape[-1]:
+                        class_score = predictions[0, class_idx]
+                    else:
+                        class_score = predictions[0, 0]
+                
+                grads = tape.gradient(class_score, conv_output)
+                
+                if grads is None:
+                    print("Gradient None")
+                    return self._activation_based_cam(img_tensor)
+            
+            # Grad-CAM hesaplama
+            pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+            
+            conv_output_np = conv_output[0].numpy()
+            pooled_grads_np = pooled_grads.numpy()
+            
+            print(f"Conv output shape: {conv_output_np.shape}")
+            print(f"Pooled grads shape: {pooled_grads_np.shape}")
+            
+            # Weighted sum
+            heatmap = np.zeros(conv_output_np.shape[:2], dtype=np.float32)
+            for i in range(len(pooled_grads_np)):
+                heatmap += pooled_grads_np[i] * conv_output_np[:, :, i]
+            
+            # ReLU ve normalize
+            heatmap = np.maximum(heatmap, 0)
+            if np.max(heatmap) > 0:
+                heatmap = heatmap / np.max(heatmap)
+            
+            print(f"Heatmap shape: {heatmap.shape}, max: {np.max(heatmap):.4f}")
+            print("Grad-CAM basariyla olusturuldu.")
+            return heatmap
+            
+        except Exception as e:
+            print(f"Grad-CAM Error: {e}")
+            import traceback
+            traceback.print_exc()
+            return self._activation_based_cam(img_tensor)
+    
+    def _activation_based_cam(self, img_tensor):
+        """Fallback: Activation-based Class Activation Map (gradient gerektirmez)."""
+        try:
+            print("Activation-based CAM kullaniliyor...")
+            
+            # ResNet50 base modelini bul
+            base_model = None
+            for layer in self.classifier.layers:
+                if 'resnet' in layer.name.lower():
+                    base_model = layer
+                    break
+            
+            if base_model is not None:
+                # Nested model
+                try:
+                    last_conv = base_model.get_layer('conv5_block3_out')
+                except:
+                    # Son conv katmanını bul
+                    last_conv = None
+                    for layer in reversed(base_model.layers):
+                        if 'conv' in layer.name and hasattr(layer, 'output'):
+                            last_conv = layer
+                            break
+                
+                if last_conv is None:
+                    return np.zeros((224, 224))
+                
+                # Feature extractor
+                feature_model = tf.keras.Model(
+                    inputs=base_model.input,
+                    outputs=last_conv.output
+                )
+                features = feature_model(img_tensor, training=False)
+            else:
+                # Düz model - son Conv2D bul
+                last_conv = None
+                for layer in reversed(self.classifier.layers):
+                    if isinstance(layer, tf.keras.layers.Conv2D):
+                        last_conv = layer
+                        break
+                
+                if last_conv is None:
+                    return np.zeros((224, 224))
+                
+                feature_model = tf.keras.Model(
+                    inputs=self.classifier.input,
+                    outputs=last_conv.output
+                )
+                features = feature_model(img_tensor, training=False)
+            
+            # Aktivasyonların ortalamasını al
+            heatmap = tf.reduce_mean(features, axis=-1)[0].numpy()
+            heatmap = np.maximum(heatmap, 0)
+            
+            if np.max(heatmap) > 0:
+                heatmap = heatmap / np.max(heatmap)
+            
+            print(f"Activation CAM shape: {heatmap.shape}")
+            return heatmap
+            
+        except Exception as e:
+            print(f"Activation CAM Error: {e}")
+            return np.zeros((224, 224))

core/model_factory.py

@@ -0,0 +1,93 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models
+from .config import Config
+
+class ModelFactory:
+    """Factory class to reconstruct model architectures for weight loading."""
+    
+    @staticmethod
+    def build_resnet50_classifier():
+        """Reconstructs ResNet50 Classifier."""
+        # ImageNet ağırlıklarıyla başlat ki katman isimleri standart olsun
+        base_model = tf.keras.applications.ResNet50(
+            weights='imagenet', 
+            include_top=False, 
+            input_shape=Config.INPUT_SHAPE
+        )
+        x = base_model.output
+        x = layers.GlobalAveragePooling2D()(x)
+        x = layers.Dense(512, activation='relu')(x)
+        x = layers.Dropout(0.5)(x)
+        output = layers.Dense(len(Config.CLASSES), activation='softmax')(x)
+        return models.Model(inputs=base_model.input, outputs=output)
+
+    @staticmethod
+    def build_cia_net():
+        """Reconstructs CIA-Net Segmentation Model."""
+        
+        def IAM_Module(nuc, con, filters):
+            concat = layers.Concatenate()([nuc, con])
+            smooth = layers.Conv2D(filters, 3, padding='same')(concat)
+            nuc_refine = layers.Conv2D(filters, 3, padding='same', activation='relu')(smooth)
+            con_refine = layers.Conv2D(filters, 3, padding='same', activation='relu')(smooth)
+            return nuc_refine, con_refine
+
+        inputs = layers.Input(shape=(None, None, 3)) 
+        
+        # ImageNet ağırlıklarıyla başlat
+        base = tf.keras.applications.DenseNet121(
+            include_top=False, 
+            weights='imagenet', 
+            input_tensor=inputs
+        )
+        
+        # Feature Extraction Layers (Standard Keras Names)
+        enc1 = base.get_layer('conv1_relu').output
+        enc2 = base.get_layer('conv2_block6_concat').output
+        enc3 = base.get_layer('conv3_block12_concat').output
+        enc4 = base.get_layer('conv4_block24_concat').output
+        bottleneck = base.get_layer('relu').output
+
+        # Decoder Level 4
+        x = layers.Conv2D(256, 3, padding='same', activation='relu')(bottleneck)
+        x = layers.UpSampling2D()(x)
+        enc4_lat = layers.Conv2D(256, 1, padding='same')(enc4)
+        
+        m4 = layers.Add()([x, enc4_lat])
+        nuc4, con4 = IAM_Module(m4, m4, 256)
+        
+        # Decoder Level 3
+        nuc_up3 = layers.Conv2D(128, 1, padding='same')(layers.UpSampling2D()(nuc4))
+        con_up3 = layers.Conv2D(128, 1, padding='same')(layers.UpSampling2D()(con4))
+        enc3_lat = layers.Conv2D(128, 1, padding='same')(enc3)
+        
+        nuc_m3 = layers.Add()([nuc_up3, enc3_lat])
+        con_m3 = layers.Add()([con_up3, enc3_lat])
+        nuc3, con3 = IAM_Module(nuc_m3, con_m3, 128)
+        
+        # Decoder Level 2
+        nuc_up2 = layers.Conv2D(64, 1, padding='same')(layers.UpSampling2D()(nuc3))
+        con_up2 = layers.Conv2D(64, 1, padding='same')(layers.UpSampling2D()(con3))
+        enc2_lat = layers.Conv2D(64, 1, padding='same')(enc2)
+        
+        nuc_m2 = layers.Add()([nuc_up2, enc2_lat])
+        con_m2 = layers.Add()([con_up2, enc2_lat])
+        nuc2, con2 = IAM_Module(nuc_m2, con_m2, 64)
+        
+        # Decoder Level 1
+        nuc_up1 = layers.Conv2D(32, 1, padding='same')(layers.UpSampling2D()(nuc2))
+        con_up1 = layers.Conv2D(32, 1, padding='same')(layers.UpSampling2D()(con2))
+        enc1_lat = layers.Conv2D(32, 1, padding='same')(enc1)
+        
+        nuc_m1 = layers.Add()([nuc_up1, enc1_lat])
+        con_m1 = layers.Add()([con_up1, enc1_lat])
+        nuc1, con1 = IAM_Module(nuc_m1, con_m1, 32)
+        
+        # Final Output
+        final_nuc = layers.UpSampling2D()(nuc1)
+        final_con = layers.UpSampling2D()(con1)
+        
+        out_nuc = layers.Conv2D(1, 1, activation='sigmoid', name='nuclei_output')(final_nuc)
+        out_con = layers.Conv2D(1, 1, activation='sigmoid', name='contour_output')(final_con)
+        
+        return models.Model(inputs=inputs, outputs=[out_nuc, out_con])

requirements.txt

@@ -1,3 +1,11 @@
-altair
-pandas
-streamlit
+tensorflow>=2.15.0
+numpy>=1.24.3
+pandas>=2.0.3
+opencv-python-headless>=4.8.0
+matplotlib>=3.7.2
+scikit-image>=0.21.0
+scipy>=1.11.1
+streamlit>=1.31.0
+albumentations>=1.3.1
+seaborn>=0.12.2
+requests>=2.31.0

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

ui/dashboard.py

@@ -0,0 +1,195 @@
+import streamlit as st
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+def render_css():
+    """Injects custom CSS for a professional medical dashboard optimized for horizontal screens."""
+    st.markdown("""
+        <style>
+            .main { 
+                max-width: 100% !important;
+                padding: 1rem 2rem;
+            }
+            .block-container {
+                max-width: 100% !important;
+                padding-left: 2rem !important;
+                padding-right: 2rem !important;
+            }
+            h1, h2, h3 { 
+                font-family: 'Segoe UI', sans-serif; 
+                font-weight: 600; 
+            }
+            
+            div[data-testid="stMetric"] {
+                padding: 18px;
+                border-radius: 12px;
+                box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+            }
+            
+            img { 
+                border-radius: 10px; 
+                box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+                image-rendering: -webkit-optimize-contrast;
+                image-rendering: crisp-edges;
+            }
+            
+            .report-box {
+                padding: 24px;
+                border-radius: 12px;
+                border-left: 6px solid #dc3545;
+                margin-bottom: 20px;
+                box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+            }
+            
+            .stTabs [data-baseweb="tab-list"] {
+                gap: 8px;
+            }
+            .stTabs [data-baseweb="tab"] {
+                padding: 12px 24px;
+                border-radius: 8px;
+            }
+            
+            .dataframe {
+                font-size: 0.95rem !important;
+            }
+        </style>
+    """, unsafe_allow_html=True)
+
+def render_header(app_name, version):
+    st.title(app_name)
+    st.caption(f"Klinik Karar Destek Sistemi | Sürüm: {version}")
+    st.markdown("---")
+
+def apply_heatmap_overlay(img_rgb, heatmap_float, colormap=cv2.COLORMAP_JET, alpha=0.6):
+    if np.max(heatmap_float) > 0:
+        heatmap_float = heatmap_float / np.max(heatmap_float)
+    heatmap_uint8 = np.uint8(255 * heatmap_float)
+    heatmap_colored = cv2.applyColorMap(heatmap_uint8, colormap)
+    heatmap_colored = cv2.cvtColor(heatmap_colored, cv2.COLOR_BGR2RGB)
+    
+    if heatmap_colored.shape[:2] != img_rgb.shape[:2]:
+        heatmap_colored = cv2.resize(heatmap_colored, (img_rgb.shape[1], img_rgb.shape[0]))
+        
+    overlay = cv2.addWeighted(img_rgb, 1-alpha, heatmap_colored, alpha, 0)
+    return overlay
+
+def render_classification_panel(img_rgb, diagnosis, cls_conf, seg_conf, gradcam_map):
+    st.subheader("1. Tanı ve Model Güven Analizi")
+    
+    col_diag, col_orig, col_xai = st.columns([1.2, 1.4, 1.4])
+    
+    with col_diag:
+        # Dynamic Styling based on Diagnosis
+        color = "#dc3545" if "Benign" not in diagnosis else "#28a745"
+        st.markdown(f"""
+        <div style="padding: 24px; border-radius: 12px; border-left: 6px solid {color}; box-shadow: 0 4px 12px rgba(0,0,0,0.1);">
+            <h3 style="margin:0; color: {color} !important; font-size: 1.8rem;">{diagnosis}</h3>
+            <p style="margin-top: 12px;">Yapay Zeka Nihai Kararı</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("#### Güvenilirlik Metrikleri")
+        c1, c2 = st.columns(2)
+        c1.metric("Teşhis Güveni", f"%{cls_conf*100:.1f}", help="ResNet50 modelinin sınıflandırma kesinliği.")
+        c2.metric("Segmentasyon Güveni", f"%{seg_conf*100:.1f}", help="CIA-Net modelinin hücre tespit kesinliği (Ortalama Piksel Olasılığı).")
+
+        if cls_conf < 0.70:
+            st.warning("Düşük güven skoru. Lütfen manuel inceleme yapınız.")
+
+    with col_orig:
+        st.image(img_rgb, caption="Orijinal Görüntü", width="stretch")
+
+    with col_xai:
+        overlay = apply_heatmap_overlay(img_rgb, gradcam_map, alpha=0.5)
+        st.image(overlay, caption="Yapay Zeka Odak Alanları (Grad-CAM)", width="stretch")
+
+def render_segmentation_panel(img_rgb, nuc_map, uncertainty_map, instance_mask, stats):
+    st.markdown("---")
+    st.subheader("2. Hücresel Morfoloji ve Biyolojik Analiz")
+    
+    tab_seg, tab_unc, tab_data, tab_plots = st.tabs([
+        "Segmentasyon", 
+        "Belirsizlik (Uncertainty)", 
+        "Kantitatif Veriler", 
+        "Dağılım Grafikleri"
+    ])
+    
+    with tab_seg:
+        c1, c2 = st.columns(2)
+        with c1:
+            nuc_colored = apply_heatmap_overlay(img_rgb, nuc_map, colormap=cv2.COLORMAP_OCEAN, alpha=0.6)
+            st.image(nuc_colored, caption="Nükleus Olasılık Haritası (AI Çıktısı)", width="stretch")
+        with c2:
+            mask_rgb = np.zeros_like(img_rgb)
+            mask_rgb[instance_mask > 0] = [0, 255, 0] # Green
+            overlay = cv2.addWeighted(img_rgb, 0.7, mask_rgb, 0.3, 0)
+            st.image(overlay, caption="Ayrıştırılmış Hücreler (Watershed)", width="stretch")
+
+    with tab_unc:
+        c1, c2 = st.columns([1, 2])
+        with c1:
+            st.info("""
+            **Nasıl Okunmalı?**
+            *   **Siyah/Koyu Alanlar:** Modelin kararından %100 emin olduğu bölgeler.
+            *   **Parlak/Sarı Alanlar:** Modelin kararsız kaldığı ("Burası hücre mi değil mi?") bölgeler.
+            
+            Sarı alanların çokluğu, görüntünün kalitesiz veya dokunun karmaşık olduğunu gösterir.
+            """)
+        with c2:
+            unc_colored = apply_heatmap_overlay(img_rgb, uncertainty_map, colormap=cv2.COLORMAP_INFERNO, alpha=0.7)
+            st.image(unc_colored, caption="Model Entropi (Belirsizlik) Haritası", width="stretch")
+
+    with tab_data:
+        if not stats.empty:
+            m1, m2, m3, m4 = st.columns(4)
+            m1.metric("Toplam Hücre", f"{len(stats)}")
+            m2.metric("Ort. Alan", f"{stats['Area'].mean():.1f} px")
+            m3.metric("Düzensizlik", f"{1 - stats['Circularity'].mean():.2f}", help="0'a yaklaştıkça hücreler daha yuvarlak (sağlıklı) demektir.")
+            m4.metric("Varyasyon", f"{stats['Area'].std():.1f}", help="Yüksek varyasyon (Anizonükleoz) kanser belirtisi olabilir.")
+            
+            st.dataframe(
+                stats.style.background_gradient(cmap='Reds', subset=['Area'])
+                           .format("{:.2f}"), 
+                width="stretch"
+            )
+        else:
+            st.warning("Hücre tespit edilemedi.")
+
+    with tab_plots:
+        if not stats.empty:
+            # HD Graphics Settings - High DPI
+            plt.style.use('seaborn-v0_8-whitegrid')
+            sns.set_context("notebook", font_scale=1.3)
+            sns.set_palette("husl")
+            
+            c1, c2 = st.columns(2)
+            with c1:
+                fig, ax = plt.subplots(figsize=(10, 6), dpi=150)
+                sns.histplot(stats['Area'], kde=True, ax=ax, color='#3498db', fill=True, alpha=0.7, linewidth=2)
+                ax.set_title("Hücre Boyut Dağılımı (Histogram)", fontsize=16, fontweight='bold', pad=20)
+                ax.set_xlabel("Alan (Piksel)", fontsize=13, fontweight='600')
+                ax.set_ylabel("Frekans", fontsize=13, fontweight='600')
+                ax.spines['top'].set_visible(False)
+                ax.spines['right'].set_visible(False)
+                ax.grid(True, alpha=0.3, linestyle='--')
+                plt.tight_layout()
+                st.pyplot(fig)
+                plt.close()
+                
+            with c2:
+                fig, ax = plt.subplots(figsize=(10, 6), dpi=150)
+                scatter = sns.scatterplot(data=stats, x='Area', y='Circularity', hue='Solidity', 
+                                         ax=ax, palette='viridis', s=100, alpha=0.8, edgecolor='white', linewidth=1.5)
+                ax.set_title("Boyut vs. Şekil Düzensizliği", fontsize=16, fontweight='bold', pad=20)
+                ax.set_xlabel("Alan (Piksel)", fontsize=13, fontweight='600')
+                ax.set_ylabel("Dairesellik", fontsize=13, fontweight='600')
+                ax.spines['top'].set_visible(False)
+                ax.spines['right'].set_visible(False)
+                ax.grid(True, alpha=0.3, linestyle='--')
+                ax.legend(title='Solidity', title_fontsize=11, fontsize=10, loc='best', frameon=True, 
+                         fancybox=True, shadow=True, framealpha=0.95)
+                plt.tight_layout()
+                st.pyplot(fig)
+                plt.close()