restore to original

app.py

@@ -376,7 +376,7 @@ def preprocess_for_unet(image_path):
     img_t = img.transpose(2, 0, 1)
     img_t = torch.from_numpy(img_t).unsqueeze(0).to(DEVICE)
     img_t = normalize(img_t)
-    return img_t, img
+    return img_t, img  # tensor + [0,1] RGB
 
 def denormalize(tensor):
     means = torch.tensor([0.485, 0.456, 0.406], device=DEVICE).view(1, 3, 1, 1)
@@ -431,7 +431,7 @@ def extract_macula_area(image_pil):
 
     with torch.no_grad():
         output = segformer_macula_segmentation_model(img_tensor)
-        mask = (output > 0.5).float()
+        mask = (output > 0.5).float()   # (1,1,H,W)
 
     macula_area = mask.sum().item()
     return macula_area
@@ -445,16 +445,26 @@ def fit_min_enclosing_circle(mask_np):
     (x, y), radius = cv2.minEnclosingCircle(largest)
     return (x, y), radius, 2 * radius
 
+def blend_image_with_mask(image, mask, alpha=0.8, mask_color=(0, 0, 255)):
+    image = image.cpu().permute(1, 2, 0).numpy()
+    mask  = mask.cpu().numpy()
+    mask_rgb = np.zeros_like(image)
+    for i in range(3):
+        mask_rgb[..., i] = mask * mask_color[i]
+    blended = (1 - alpha) * image + alpha * mask_rgb
+    return np.clip(blended, 0, 1)
+
 def refine_mask(mask):
     m = mask.cpu().numpy().squeeze()
     m = ndimage.binary_closing(m, structure=np.ones((3, 3)), iterations=1)
-    return torch.from_numpy(m).float().to(DEVICE)
+    return torch.from_numpy(m).float().to(DEVICE)  # Ensure on correct device
 
 def load_image_from_pil(image_pil, device):
     transform = transforms.Compose([
         transforms.Resize((128, 128)),
         transforms.ToTensor(),
-        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                             std=[0.229, 0.224, 0.225])
     ])
     return transform(image_pil).unsqueeze(0).to(device)
 
@@ -463,16 +473,17 @@ def compute_vasculature_density(image_pil, model, device, threshold=0.05, radius
     with torch.no_grad():
         img_tensor = load_image_from_pil(image_pil, device)
         output = model(img_tensor)
-        pred = (output > threshold).float()
+        pred   = (output > threshold).float()
         refined = refine_mask(pred)
         h, w = refined.shape[-2], refined.shape[-1]
-        roi = create_circular_roi_mask((h, w), radius_ratio)
+        roi  = create_circular_roi_mask((h, w), radius_ratio)
         roi_tensor = torch.from_numpy(roi).to(device)
         masked = refined * roi_tensor
         vessel_area = masked.sum().item()
-        roi_area = roi_tensor.sum().item()
+        roi_area    = roi_tensor.sum().item()
         density = vessel_area / roi_area if roi_area > 0 else 0.0
-    return density
+
+        return density
 
 def create_circular_roi_mask(image_shape, radius_ratio=0.95):
     h, w = image_shape
@@ -487,150 +498,136 @@ def create_dataset_statistics(df):
     df["optic_cup_diameter"] = pd.to_numeric(df["optic_cup_diameter"], errors="coerce")
     df["optic_disc_diameter"] = pd.to_numeric(df["optic_disc_diameter"], errors="coerce")
     df["macula_diameter"] = pd.to_numeric(df["macula_diameter"], errors="coerce")
-    df["vasculature_density"] = pd.to_numeric(df["vasculature_density"], errors="coerce")
+    df["vasculature_density"] = pd.to_numeric(df["macula_diameter"], errors="coerce")
     
     df["retina_radius"] = df["retina_diameter"] / 2
     df["retina_area"] = np.pi * (df["retina_radius"] ** 2)
     df["retina_circumference"] = 2 * np.pi * df["retina_radius"]
+
     df["optic_cup_radius"] = df["optic_cup_diameter"] / 2
     df["optic_cup_area"] = np.pi * (df["optic_cup_radius"] ** 2)
     df["optic_cup_circumference"] = 2 * np.pi * df["optic_cup_radius"]
+
     df["optic_disc_radius"] = df["optic_disc_diameter"] / 2
     df["optic_disc_area"] = np.pi * (df["optic_disc_radius"] ** 2)
     df["optic_disc_circumference"] = 2 * np.pi * df["optic_disc_radius"]
+
     df["macula_radius"] = df["macula_diameter"] / 2
     df["macula_area"] = np.pi * (df["macula_radius"] ** 2)
     df["macula_circumference"] = 2 * np.pi * df["macula_radius"]
 
     df["optic_disc_to_retina_diameter_ratio"] = df["optic_disc_diameter"] / df["retina_diameter"]
     df["optic_disc_to_retina_area_ratio"] = df["optic_disc_area"] / df["retina_area"]
+
     df["optic_cup_to_disc_diameter_ratio"] = df["optic_cup_diameter"] / df["optic_disc_diameter"]
     df["optic_cup_to_disc_area_ratio"] = df["optic_cup_area"] / df["optic_disc_area"]
+
     df["optic_cup_to_retina_diameter_ratio"] = df["optic_cup_diameter"] / df["retina_diameter"]
     df["optic_cup_to_retina_area_ratio"] = df["optic_cup_area"] / df["retina_area"]
     
+    print("Dataset statistics succesfully generated")
+
     return df
 
 def reorder_df(df):
-    return df[["retina_diameter", "optic_disc_diameter", "optic_cup_diameter", "macula_diameter", "vasculature_density",
-               "retina_radius", "retina_area", "retina_circumference", "optic_cup_radius", "optic_cup_area",
-               "optic_cup_circumference", "optic_disc_radius", "optic_disc_area", "optic_disc_circumference",
-               "macula_radius", "macula_area", "macula_circumference", "optic_disc_to_retina_diameter_ratio",
-               "optic_disc_to_retina_area_ratio", "optic_cup_to_disc_diameter_ratio", "optic_cup_to_disc_area_ratio",
-               "optic_cup_to_retina_diameter_ratio", "optic_cup_to_retina_area_ratio"]]
+    df = df[["retina_diameter", 
+         "optic_disc_diameter", "optic_cup_diameter",
+         "macula_diameter",
+         "vasculature_density",
+         "retina_radius", "retina_area",
+         "retina_circumference", "optic_cup_radius",
+         "optic_cup_area", "optic_cup_circumference",
+         "optic_disc_radius", "optic_disc_area",
+         "optic_disc_circumference", 
+         "macula_radius", "macula_area", "macula_circumference",
+         "optic_disc_to_retina_diameter_ratio",
+         "optic_disc_to_retina_area_ratio", "optic_cup_to_disc_diameter_ratio",
+         "optic_cup_to_disc_area_ratio", "optic_cup_to_retina_diameter_ratio",
+         "optic_cup_to_retina_area_ratio"
+        ]]
+
+    return df
 
 def load_scaler(scaler_file_path):
-    with open(scaler_file_path, 'rb') as f:
+    with open(f'{scaler_file_path}', 'rb') as f:
         scaler = pickle.load(f)
+    print("Scaler loaded successfully")
+        
     return scaler
 
 def predict_multimodal(model, image_path, df_row, device=DEVICE):
     model.eval()
+
     image_pil = Image.open(image_path).convert("RGB")
+
     img = test_val_transform(image_pil).unsqueeze(0).to(device)
-    numeric_data = torch.tensor(df_row.astype(float).values, dtype=torch.float32).unsqueeze(0).to(device)
+
+    numeric_data = torch.tensor(
+        df_row.iloc[:].astype(float).values,
+        dtype=torch.float32
+    ).unsqueeze(0).to(device)
+
     with torch.no_grad():
         logits = model(img, numeric_data)
         probs = torch.softmax(logits, dim=1)
         confidence, pred_class = torch.max(probs, dim=1)
+
+    print(probs)
+
     return {
         "pred_class": int(pred_class.item()),
         "confidence": float(confidence.item()),
         "probabilities": probs.cpu().numpy().flatten().tolist()
     }
 
-# ==================== NEW: Full Segmentation Visualization ====================
-
-def create_full_segmentation_visualization(image_path, retina_diameter, cup_mask, disc_mask, macula_mask, vessel_mask,
-                                           cup_center=None, cup_radius=None, disc_center=None, disc_radius=None,
-                                           retina_center=None, retina_radius=None):
-    img = cv2.imread(image_path)
-    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-    h, w = img_rgb.shape[:2]
-    
-    # Resize masks
-    cup_mask_r = cv2.resize(cup_mask, (w, h), interpolation=cv2.INTER_NEAREST)
-    disc_mask_r = cv2.resize(disc_mask, (w, h), interpolation=cv2.INTER_NEAREST)
-    macula_mask_r = cv2.resize(macula_mask, (w, h), interpolation=cv2.INTER_NEAREST)
-    vessel_mask_r = cv2.resize(vessel_mask, (w, h), interpolation=cv2.INTER_NEAREST)
-
-    vis = img_rgb.copy().astype(np.float32) / 255.0
-
-    # Overlays (order matters)
-    vis[vessel_mask_r > 0.5] = vis[vessel_mask_r > 0.5] * 0.5 + np.array([0, 1, 1]) * 0.5   # Cyan vasculature
-    vis[macula_mask_r > 0.5] = vis[macula_mask_r > 0.5] * 0.6 + np.array([1, 1, 0]) * 0.4  # Yellow macula
-    vis[cup_mask_r > 0.5] = vis[cup_mask_r > 0.5] * 0.5 + np.array([0, 0, 1]) * 0.5       # Blue cup
-    vis[disc_mask_r > 0.5] = vis[disc_mask_r > 0.5] * 0.6 + np.array([0, 1, 0]) * 0.4     # Green disc
-
-    # Circles
-    if retina_center and retina_radius:
-        cv2.circle(vis, (int(retina_center[0]), int(retina_center[1])), int(retina_radius), (1, 0, 0), 4)  # Red
-    if disc_center and disc_radius:
-        cv2.circle(vis, (int(disc_center[0]), int(disc_center[1])), int(disc_radius), (0, 1, 0), 3)     # Green
-    if cup_center and cup_radius:
-        cv2.circle(vis, (int(cup_center[0]), int(cup_center[1])), int(cup_radius), (0, 0, 1), 3)       # Blue
-
-    # Legend with matplotlib
-    fig, ax = plt.subplots(1, 1, figsize=(12, 12))
-    ax.imshow(vis)
-    ax.axis('off')
-    legend_elements = [
-        patches.Patch(facecolor=(1,0,0,0.6), edgecolor='r', label='Retina Boundary'),
-        patches.Patch(facecolor=(0,1,0,0.6), edgecolor='g', label='Optic Disc'),
-        patches.Patch(facecolor=(0,0,1,0.6), edgecolor='b', label='Optic Cup'),
-        patches.Patch(facecolor=(1,1,0,0.6), edgecolor='y', label='Macula'),
-        patches.Patch(facecolor=(0,1,1,0.6), edgecolor='c', label='Vasculature')
-    ]
-    ax.legend(handles=legend_elements, loc='upper right', fontsize=14, framealpha=0.95)
-
-    buf = io.BytesIO()
-    plt.savefig(buf, format='png', bbox_inches='tight', dpi=150)
-    plt.close(fig)
-    buf.seek(0)
-    return buf
-
-# ==================== MAIN PREDICTION FUNCTION (updated) ====================
-
-fmt = "{:.3f}"
 
 def predict_all_diameters(image_path):
     if image_path is None:
         return "Please upload an image.", None
 
     image_pil = Image.open(image_path).convert('RGB')
-    img_tensor, _ = preprocess_for_unet(image_path)
 
-    # Macula
     macula_area = extract_macula_area(image_pil)
     macula_radius = (macula_area / math.pi) ** 0.5
     macula_diameter = 2 * macula_radius
-
-    # Retina
+    
     retina_diameter = get_retina_statistics_from_image(image_path)
-    if retina_diameter == "NA":
-        retina_diameter = "NA"
+    if retina_diameter is None:
+        retina_diameter = "Not detected"
+
+    img_tensor, img_rgb = preprocess_for_unet(image_path)
 
-    # Optic disc & cup
     with torch.no_grad():
         cup_out = optic_cup_segmentation_model(img_tensor)
         disc_out = optic_disc_segmentation_model(img_tensor)
         cup_mask = (cup_out > 0.5).float().cpu().numpy()[0, 0]
         disc_mask = (disc_out > 0.5).float().cpu().numpy()[0, 0]
 
-    cup_center_full, cup_radius_full, cup_diameter = fit_min_enclosing_circle(cv2.resize(cup_mask, (cv2.imread(image_path).shape[1], cv2.imread(image_path).shape[0]), cv2.INTER_NEAREST))
-    disc_center_full, disc_radius_full, disc_diameter = fit_min_enclosing_circle(cv2.resize(disc_mask, (cv2.imread(image_path).shape[1], cv2.imread(image_path).shape[0]), cv2.INTER_NEAREST))
+    _, _, cup_diameter = fit_min_enclosing_circle(cup_mask)
+    _, _, disc_diameter = fit_min_enclosing_circle(disc_mask)
 
-    # Macula mask
-    with torch.no_grad():
-        macula_out = segformer_macula_segmentation_model(img_tensor)
-        macula_mask = (macula_out > 0.5).float().cpu().numpy()[0, 0]
+    cdr = cup_diameter / disc_diameter if (cup_diameter and disc_diameter and disc_diameter > 0) else None
+
+    img_vis = denormalize(img_tensor).squeeze(0).permute(1, 2, 0).cpu().numpy()
+
+    h, w = img_vis.shape[:2]
+    cup_mask_resized = cv2.resize(cup_mask, (w, h), interpolation=cv2.INTER_NEAREST)
+    disc_mask_resized = cv2.resize(disc_mask, (w, h), interpolation=cv2.INTER_NEAREST)
+
+    vis = img_vis.copy()
+    vis[cup_mask_resized > 0.5] = vis[cup_mask_resized > 0.5] * 0.4 + np.array([1, 0, 0]) * 0.6
+    vis[disc_mask_resized > 0.5] = vis[disc_mask_resized > 0.5] * 0.6 + np.array([0, 1, 0]) * 0.4
+
+    vis_uint8 = (vis * 255).astype(np.uint8)
+    vis_bgr = cv2.cvtColor(vis_uint8, cv2.COLOR_RGB2BGR)
 
-    # Vasculature
-    vd = compute_vasculature_density(image_pil, retinal_vasculature_segmentation_model, DEVICE)
+    if cup_diameter:
+        (cx, cy), r, _ = fit_min_enclosing_circle(cup_mask_resized)
+        cv2.circle(vis_bgr, (int(cx), int(cy)), int(r), (255, 0, 0), 2)
+    if disc_diameter:
+        (cx, cy), r, _ = fit_min_enclosing_circle(disc_mask_resized)
+        cv2.circle(vis_bgr, (int(cx), int(cy)), int(r), (0, 255, 0), 2)
 
-    # Retina center/radius for visualization
-    retina_center = None
-    retina_radius_val = None
     if isinstance(retina_diameter, float):
         img_full = cv2.imread(image_path)
         gray = cv2.cvtColor(img_full, cv2.COLOR_BGR2GRAY)
@@ -640,127 +637,258 @@ def predict_all_diameters(image_path):
         if circles is not None:
             circles = np.uint16(np.around(circles))
             largest = circles[0, np.argmax(circles[0, :, 2])]
-            retina_center = (largest[0], largest[1])
-            retina_radius_val = largest[2]
-
-    # Visualization
-    vis_buf = create_full_segmentation_visualization(
-        image_path, retina_diameter, cup_mask, disc_mask, macula_mask,
-        refine_mask((retinal_vasculature_segmentation_model(img_tensor) > 0.05).float()).cpu().numpy()[0,0],
-        cup_center=cup_center_full, cup_radius=cup_radius_full,
-        disc_center=disc_center_full, disc_radius=disc_radius_full,
-        retina_center=retina_center, retina_radius=retina_radius_val
+            x, y, r = largest
+            cv2.circle(vis_bgr, (x, y), r, (0, 0, 255), 2)  # Red circle for retina
+
+    vis_rgb = cv2.cvtColor(vis_bgr, cv2.COLOR_BGR2RGB) / 255.0
+
+    vd = compute_vasculature_density(
+            image_pil=image_pil,
+            model=retinal_vasculature_segmentation_model,
+            device=DEVICE,
+            threshold=0.05,
+            radius_ratio=0.95
     )
 
-    # Dataframe and prediction
+    if not retina_diameter:
+        retina_diameter = "NA"
+    if not cup_diameter:
+        cup_diameter = "NA"
+    if not disc_diameter:
+        disc_diameter = "NA"
+    if not vd:
+        vd = "NA"
+    if not macula_diameter:
+        macula_diameter = "NA"
+
+    df = pd.DataFrame()
     df = pd.DataFrame([{
-        "retina_diameter": retina_diameter if isinstance(retina_diameter, float) else None,
+        "retina_diameter": retina_diameter,
         "optic_cup_diameter": cup_diameter,
         "optic_disc_diameter": disc_diameter,
         "macula_diameter": macula_diameter,
         "vasculature_density": vd
     }])
 
-    original_df = create_dataset_statistics(df.copy())
+    df = create_dataset_statistics(df)
     df = reorder_df(df)
+    print(df)
 
-    scaler_path = hf_hub_download(repo_id="rprkh/multimodal_glaucoma_classification", filename="scaler.pkl", use_auth_token=secret_value_0)
-    scaler = load_scaler(scaler_path)
-    scaled = scaler.transform(df)
-    df_scaled = pd.DataFrame(scaled, columns=df.columns)
-
-    result = predict_multimodal(multimodal_glaucoma_classification_model, image_path, df_scaled.iloc[0])
+    original_df = df
+    
+    scaler_path = hf_hub_download(
+        repo_id="rprkh/multimodal_glaucoma_classification",
+        filename="scaler.pkl",
+        use_auth_token=secret_value_0
+    )
+    standard_scaler = load_scaler(f"{scaler_path}")
+    scaled_array = standard_scaler.transform(df.iloc[:, :])
+    print("Data scaled successfully")
+    print(df)
+
+    df = pd.DataFrame(scaled_array, columns=df.columns)
+    df_row = df.iloc[0]
+
+    result = predict_multimodal(
+        model=multimodal_glaucoma_classification_model,
+        image_path=image_path,
+        df_row=df_row,
+        device=DEVICE
+    )
 
     pred_class = result["pred_class"]
     confidence = result["confidence"]
-    prediction = "Glaucomatous Retina" if pred_class == 1 else "Non-Glaucomatous Retina"
 
-    def get_val(col, default="NA"):
-        val = original_df[col].iloc[0]
-        return fmt.format(val) if pd.notna(val) else default
-
-    # Conversion helpers
-    def convert_to_mm(x): return "N/A" if x in ["NA", None] else str(round(float(x) * 0.06818, 3))
-    def convert_to_mm2(x): return "N/A" if x in ["NA", None] else str(round(float(x) * 0.06818**2, 3))
-    def round3(x): return "N/A" if x in ["NA", None] else str(round(float(x), 3))
+    if pred_class == 0:
+        prediction = "Non-Glaucomatous Retina"
+    if pred_class == 1:
+        prediction = "Glaucomatous Retina"
+
+    def get_df_value(df, col_name, default="NA"):
+        if col_name not in df.columns:
+            return default
+        val = df[col_name].iloc[0]
+        if pd.isna(val) or val == "NA":
+            return default
+        try:
+            return fmt.format(val)
+        except Exception:
+            return str(val)
+
+    retina_radius = get_df_value(original_df, "retina_radius")
+    retina_area = get_df_value(original_df, "retina_area")
+    retina_circumference = get_df_value(original_df, "retina_circumference")
+    
+    optic_cup_radius = get_df_value(original_df, "optic_cup_radius")
+    optic_cup_area = get_df_value(original_df, "optic_cup_area")
+    optic_cup_circumference = get_df_value(original_df, "optic_cup_circumference")
+    
+    optic_disc_radius = get_df_value(original_df, "optic_disc_radius")
+    optic_disc_area = get_df_value(original_df, "optic_disc_area")
+    optic_disc_circumference = get_df_value(original_df, "optic_disc_circumference")
+    
+    macula_radius = get_df_value(original_df, "macula_radius")
+    macula_area = get_df_value(original_df, "macula_area")
+    macula_circumference = get_df_value(original_df, "macula_circumference")
+    
+    optic_disc_to_retina_diameter_ratio = get_df_value(original_df, "optic_disc_to_retina_diameter_ratio")
+    optic_disc_to_retina_area_ratio = get_df_value(original_df, "optic_disc_to_retina_area_ratio")
+    
+    optic_cup_to_disc_diameter_ratio = get_df_value(original_df, "optic_cup_to_disc_diameter_ratio")
+    optic_cup_to_disc_area_ratio = get_df_value(original_df, "optic_cup_to_disc_area_ratio")
+    optic_cup_to_retina_diameter_ratio = get_df_value(original_df, "optic_cup_to_retina_diameter_ratio")
+    optic_cup_to_retina_area_ratio = get_df_value(original_df, "optic_cup_to_retina_area_ratio")
+
+    def convert_to_mm(measurement):
+        try:
+            measurement = float(measurement)
+            measurement = measurement * 0.06818
+            measurement = round(measurement, 3)
+        except:
+            measurement = "N/A"
+
+        return measurement
+
+    def convert_to_mm2(measurement):
+        try:
+            measurement = float(measurement)
+            measurement = measurement * 0.06818 * 0.06818
+            measurement = round(measurement, 3)
+        except:
+            measurement = "N/A"
+
+        return measurement
+
+    def round_measurement_to_3_dp(measurement):
+        try:
+            measurement = float(measurement)
+            measurement = round(measurement, 3)
+        except:
+            measurement = "N/A"
+
+        return measurement
 
-    # Fixed result HTML
     result_text = f"""
-    <div id="results_container">
-    <div id="results_table" style="display:flex; gap:7px;">
-    <div style="flex:1;"><table>
-    <tr><th>Measurement</th><th>Value</th></tr>
-    <tr><td><b>Retina Diameter</b></td><td>{convert_to_mm(retina_diameter)} mm</td></tr>
-    <tr><td><b>Optic Cup Diameter</b></td><td>{convert_to_mm(cup_diameter)} mm</td></tr>
-    <tr><td><b>Optic Disc Diameter</b></td><td>{convert_to_mm(disc_diameter)} mm</td></tr>
-    <tr><td><b>Macular Diameter</b></td><td>{convert_to_mm(macula_diameter)} mm</td></tr>
-    <tr><td><b>Vasculature Density</b></td><td>{round(vd * 100, 3)}%</td></tr>
-    <tr><td><b>Retina Radius</b></td><td>{convert_to_mm(get_val('retina_radius', 'NA'))} mm</td></tr>
-    <tr><td><b>Retina Area</b></td><td>{convert_to_mm2(get_val('retina_area', 'NA'))} mm<sup>2</sup></td></tr>
-    <tr><td><b>Retina Circumference</b></td><td>{convert_to_mm(get_val('retina_circumference', 'NA'))} mm</td></tr>
-    </table></div>
-
-    <div style="flex:1;"><table>
-    <tr><th>Measurement</th><th>Value</th></tr>
-    <tr><td><b>Optic Cup Radius</b></td><td>{convert_to_mm(get_val('optic_cup_radius', 'NA'))} mm</td></tr>
-    <tr><td><b>Optic Cup Area</b></td><td>{convert_to_mm2(get_val('optic_cup_area', 'NA'))} mm<sup>2</sup></td></tr>
-    <tr><td><b>Optic Cup Circumference</b></td><td>{convert_to_mm(get_val('optic_cup_circumference', 'NA'))} mm</td></tr>
-    <tr><td><b>Optic Disc Radius</b></td><td>{convert_to_mm(get_val('optic_disc_radius', 'NA'))} mm</td></tr>
-    <tr><td><b>Optic Disc Area</b></td><td>{convert_to_mm2(get_val('optic_disc_area', 'NA'))} mm<sup>2</sup></td></tr>
-    <tr><td><b>Optic Disc Circumference</b></td><td>{convert_to_mm(get_val('optic_disc_circumference', 'NA'))} mm</td></tr>
-    <tr><td><b>Macula Radius</b></td><td>{convert_to_mm(get_val('macula_radius', 'NA'))} mm</td></tr>
-    <tr><td><b>Macula Area</b></td><td>{convert_to_mm2(get_val('macula_area', 'NA'))} mm<sup>2</sup></td></tr>
-    </table></div>
-
-    <div style="flex:1;"><table>
-    <tr><th>Measurement</th><th>Value</th></tr>
-    <tr><td><b>Macula Circumference</b></td><td>{convert_to_mm(get_val('macula_circumference', 'NA'))} mm</td></tr>
-    <tr><td><b>Optic Disc to Retina Diameter Ratio</b></td><td>{round3(get_val('optic_disc_to_retina_diameter_ratio', 'NA'))}</td></tr>
-    <tr><td><b>Optic Disc to Retina Area Ratio</b></td><td>{round3(get_val('optic_disc_to_retina_area_ratio', 'NA'))}</td></tr>
-    <tr><td><b>Optic Cup to Disc Diameter Ratio (CDR)</b></td><td>{round3(get_val('optic_cup_to_disc_diameter_ratio', 'NA'))}</td></tr>
-    <tr><td><b>Optic Cup to Disc Area Ratio</b></td><td>{round3(get_val('optic_cup_to_disc_area_ratio', 'NA'))}</td></tr>
-    <tr><td><b>Optic Cup to Retina Diameter Ratio</b></td><td>{round3(get_val('optic_cup_to_retina_diameter_ratio', 'NA'))}</td></tr>
-    <tr><td><b>Optic Cup to Retina Area Ratio</b></td><td>{round3(get_val('optic_cup_to_retina_area_ratio', 'NA'))}</td></tr>
-    </table></div>
-    </div>
-    <h3>Predicted Class: {prediction}</h3>
-    <h3>Confidence: {round(confidence * 100, 3)}%</h3>
-    </div>
-    """
+<div id="results_container">
+<div id="results_table" style="display:flex; gap:7px;">
+<div style="flex:1;">
+<table>
+<tr><th>Measurement</th><th>Value</th></tr>
+
+<tr><td><b>Retina Diameter</b></td><td>{convert_to_mm(retina_diameter)} mm</td></tr>
+<tr><td><b>Optic Cup Diameter</b></td><td>{convert_to_mm(cup_diameter)} mm</td></tr>
+<tr><td><b>Optic Disc Diameter</b></td><td>{convert_to_mm(disc_diameter)} mm</td></tr>
+<tr><td><b>Macular Diameter</b></td><td>{convert_to_mm(macula_diameter)} mm</td></tr>
+<tr><td><b>Vasculature Density</b></td><td>{round(vd * 100, 3)}%</td></tr>
+
+<tr><td><b>Retina Radius</b></td><td>{convert_to_mm(retina_radius)} mm</td></tr>
+<tr><td><b>Retina Area</b></td><td>{convert_to_mm2(retina_area)} mm<sup>2</sup></td></tr>
+<tr><td><b>Retina Circumference</b></td><td>{convert_to_mm(retina_circumference)} mm</td></tr>
+</table>
+</div>
+
+<div style="flex:1;">
+<table>
+<tr><th>Measurement</th><th>Value</th></tr>
+
+<tr><td><b>Optic Cup Radius</b></td><td>{convert_to_mm(optic_cup_radius)} mm</td></tr>
+<tr><td><b>Optic Cup Area</b></td><td>{convert_to_mm2(optic_disc_area)} mm<sup>2</sup></td></tr>
+<tr><td><b>Optic Cup Circumference</b></td><td>{convert_to_mm(optic_cup_circumference)} mm</td></tr>
+
+<tr><td><b>Optic Disc Radius</b></td><td>{convert_to_mm(optic_disc_radius)} mm</td></tr>
+<tr><td><b>Optic Disc Area</b></td><td>{convert_to_mm2(optic_cup_area)} mm<sup>2</sup></td></tr>
+<tr><td><b>Optic Disc Circumference</b></td><td>{convert_to_mm(optic_disc_circumference)} mm</td></tr>
+
+<tr><td><b>Macula Radius</b></td><td>{convert_to_mm(macula_radius)} mm</td></tr>
+<tr><td><b>Macula Area</b></td><td>{convert_to_mm(macula_area)} mm</td></tr>
+
+</table>
+</div>
+
+<div style="flex:1;">
+<table>
+<tr><th>Measurement</th><th>Value</th></tr>
+
+<tr><td><b>Macula Circumference</b></td><td>{convert_to_mm(macula_circumference)} mm</td></tr>
+
+<tr><td><b>Optic Disc to Retina Diameter Ratio</b></td><td>{round_measurement_to_3_dp(optic_disc_to_retina_diameter_ratio)}</td></tr>
+<tr><td><b>Optic Disc to Retina Area Ratio</b></td><td>{round_measurement_to_3_dp(optic_disc_to_retina_area_ratio)}</td></tr>
+
+<tr><td><b>Optic Cup to Disc Diameter Ratio</b></td><td>{round_measurement_to_3_dp(optic_cup_to_disc_diameter_ratio)}</td></tr>
+<tr><td><b>Optic Cup to Disc Area Ratio</b></td><td>{round_measurement_to_3_dp(optic_cup_to_disc_area_ratio)}</td></tr>
+<tr><td><b>Optic Cup to Retina Diameter Ratio</b></td><td>{round_measurement_to_3_dp(optic_cup_to_retina_diameter_ratio)}</td></tr>
+<tr><td><b>Optic Cup to Retina Area Ratio</b></td><td>{round_measurement_to_3_dp(optic_cup_to_retina_area_ratio)}</td></tr>
+</table>
+</div>
+</div>
+
+<h3>Predicted Class: {prediction}</h3>
+<h3>Confidence: {round(confidence * 100, 3)}%</h3>
+<div>
+"""
 
-    return result_text, Image.frombytes("PNG", vis_buf.size, vis_buf.getvalue())
+    return result_text
 
-# ==================== GRADIO INTERFACE ====================
 
 custom_css = """
-#container_1100, #image_box, #prediction_button, #results_container { max-width: 1100px !important; margin-left: auto !important; margin-right: auto !important; }
-.center_text { text-align: center !important; }
-.abstract_block { text-align: justify !important; max-width: 1100px !important; margin-left: auto !important; margin-right: auto !important; font-size: 15px; }
+#container_1100, #image_box, #prediction_button, #results_container {
+    max-width: 1100px !important;
+    margin-left: auto !important;
+    margin-right: auto !important;
+}
+
+.center_text {
+    text-align: center !important;
+}
+
+.abstract_block {
+    text-align: justify !important;
+    max-width: 1100px !important;
+    margin-left: auto !important;
+    margin-right: auto !important;
+    font-size: 15px;
+}
 """
 
 with gr.Blocks(title="Glaucoma Predictor", css=custom_css) as demo:
+
     gr.HTML("""
+    <!--html-->
     <div id="container_1100">
         <div class="center_text" style="font-size: 24px; font-weight: bold;">
             Multimodal Glaucoma Classification Using Segmentation Based Biomarker Extraction
-        </div><br>
+        </div>
+        <br>
+
         <div class="center_text" style="font-size: 16px;">
             Rahil Parikh<sup>a</sup>, Van Nguyen<sup>b</sup>, Anita Penkova<sup>c</sup><br>
             <sup>a</sup>Department of Computer Science, University of Southern California, Los Angeles, 90089, California, USA<br>
             <sup>b</sup>Roski Eye Institute, Keck School of Medicine, University of Southern California, Los Angeles, 90033, California, USA<br>
             <sup>c</sup>Department of Aerospace and Mechanical Engineering, University of Southern California, Los Angeles, 90089, California, USA<br>
             Email: {rahilpar, vann4675, penkova}@usc.edu
-        </div><br>
-        <div class="center_text" style="font-size: 15px; font-weight: bold;">Abstract</div>
+        </div>
+
+        <br>
+        <div class="center_text" style="font-size: 15px; font-weight: bold;">
+            Abstract
+        </div>
+
         <div class="abstract_block">
             Glaucoma is a progressive eye disease that leads to irreversible vision loss and, if not addressed promptly, 
-            can result in blindness. While various treatment options exist, early detection and diagnosis can mitigate 
+            can result in blindness. While various treatment options such as eye drops, oral medications, and surgical 
+            interventions exist, the disease may still progress. Therefore, early detection and diagnosis can mitigate 
             the devastating vision loss of glaucoma. The primary focus of the proposed study is the development of a 
-            robust pipeline for the efficient extraction of quantifiable data from fundus images. Our unique approach 
-            leverages segmentation-based models in conjunction with computer vision techniques to efficiently extract 
-            and compute clinical glaucoma biomarkers such as optic disc area and optic cup to disc ratio. The extracted 
-            biomarkers are consistent with trends observed in clinical practice. The weighted combination of image-based 
-            features with glaucoma biomarkers achieves a test accuracy of 91.38% for glaucoma classification.
+            robust pipeline for the efficient extraction of quantifiable data from fundus images. What sets our approach 
+            apart from other approaches is the emphasis on automated feature extraction of glaucoma biomarkers from 
+            particular regions of interest (ROI) along with the utilization of a weighted average of image features and 
+            clinical measurements. Our unique approach leverages segmentation based models in conjunction with 
+            computer vision techniques to efficiently extract and compute clinical glaucoma biomarkers such as optic disc 
+            area and optic cup to disc ratio. The extracted biomarkers are consistent with trends observed in clinical 
+            practice, thus supporting the validity of the feature extraction approach. While subtle disease progression, 
+            inconsistencies in image quality and a general lack of metadata impact classification performance, the 
+            weighted combination of image based features with glaucoma biomarkers achieves a test accuracy of 91.38% 
+            for glaucoma classification, successfully addressing the limitations of traditional single-modality approaches 
+            such as fundus imaging and optical coherence tomography (OCT).
         </div>
     </div>
     """)
@@ -769,15 +897,16 @@ with gr.Blocks(title="Glaucoma Predictor", css=custom_css) as demo:
         with gr.Column():
             image_input = gr.Image(type="filepath", label="Upload Fundus Image", elem_id="image_box")
             btn = gr.Button("Analyze Image", variant="primary", elem_id="prediction_button")
-
-    with gr.Row():
-        with gr.Column():
             result_md = gr.Markdown(elem_id="results_container")
-        with gr.Column():
-            vis_output = gr.Image(label="Segmentation Visualization", type="pil")
 
-    btn.click(fn=lambda: ("Analyzing... Please wait.", None), outputs=[result_md, vis_output]) \
-       .then(fn=predict_all_diameters, inputs=image_input, outputs=[result_md, vis_output])
+    btn.click(
+        fn=lambda: ("Analyzing... Please wait.",),
+        outputs=[result_md]
+    ).then(
+        fn=predict_all_diameters,
+        inputs=image_input,
+        outputs=[result_md]
+    )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()