backend/processing.py

from pathlib import Path
import cv2
import numpy as np
from skimage import measure, morphology
from utils import get_pixel_size, read_emd_image, read_emd_pixel_size
import pandas as pd
import math
from scipy import ndimage as ndi
import ncempy.io as nio
from autodetect_utils import image_kmeans, ruecs, dilmarkers, split_clump

def save_results_to_excel(results, output_path):
    """
    Saves results to an Excel file with 'Statistics' and 'Data' sheets.
    """
    # Prepare DataFrame for export
    df_export = pd.DataFrame(results)
    if df_export.empty:
        return

    # Remove contour column if present for clean export
    cols_to_drop = [c for c in ["contour", "contour_full"] if c in df_export.columns]
    df_export = df_export.drop(columns=cols_to_drop)

    # Calculate Stats for Excel
    s_mean = df_export.mean(numeric_only=True).round(1)
    s_std = df_export.std(numeric_only=True).round(1)
    
    stats_rows = []
    stats_rows.append({"Metric": "Count", "Value": len(df_export)})
    stats_rows.append({"Metric": "Mean Length (nm)", "Value": f"{s_mean.get('length_nm', 0)} ± {s_std.get('length_nm', 0)}"})
    stats_rows.append({"Metric": "Mean Width (nm)", "Value": f"{s_mean.get('width_nm', 0)} ± {s_std.get('width_nm', 0)}"})
    stats_rows.append({"Metric": "Mean AR", "Value": f"{s_mean.get('aspect_ratio', 0)} ± {s_std.get('aspect_ratio', 0)}"})
    stats_df = pd.DataFrame(stats_rows)

    # Save to Excel
    try:
        with pd.ExcelWriter(output_path) as writer:
            stats_df.to_excel(writer, sheet_name="Statistics", index=False)
            df_export.to_excel(writer, sheet_name="Data", index=False)
    except Exception as e:
        print(f"Excel export failed: {e}")


def calculate_volume(length_nm, width_nm):
    """
    Calculate volume of a hemispherically capped cylinder (nanorod).
    V = pi * r^2 * (L - 2r) + 4/3 * pi * r^3
    where r = width / 2
    """
    r = width_nm / 2.0
    # If rod is very short (L < W), treat as sphere or prolate spheroid? 
    # Standard formula assumes L >= W. If L < W, it's not a rod.
    # We'll clamp L-2r to 0 if L < 2r (though physically L should be > W for a rod)
    cyl_height = max(0, length_nm - width_nm)
    
    v_cyl = np.pi * (r**2) * cyl_height
    v_caps = (4.0/3.0) * np.pi * (r**3)
    
    return v_cyl + v_caps


def _fast_split_large_component(crop: np.ndarray, min_size_px: int):
    """
    Fast fallback for very large fused regions where recursive rUECS can be
    prohibitively slow. It separates narrow bridges, dilates markers back, and
    keeps masks constrained to the original component.
    """
    crop_bool = crop.astype(bool)
    if not np.any(crop_bool):
        return []

    area = int(crop_bool.sum())
    radius = 2 if area < 250_000 else 3
    seed = morphology.erosion(crop_bool, morphology.disk(radius))
    seed = morphology.opening(seed, morphology.disk(1))

    labeled, _ = ndi.label(seed)
    min_marker_area = max(3, int(min_size_px / 4))
    split_masks = []

    for region in measure.regionprops(labeled):
        if region.area < min_marker_area:
            continue

        marker = labeled == region.label
        grown = marker
        for _ in range(radius + 1):
            grown = morphology.dilation(grown, morphology.disk(1))

        grown &= crop_bool
        if grown.sum() >= min_marker_area:
            split_masks.append(grown)

    return split_masks or [crop_bool]


def _make_label_overlay(img: np.ndarray, labels: np.ndarray):
    base = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
    max_label = int(labels.max()) if labels.size else 0
    if max_label <= 0:
        return base

    idx = np.arange(max_label + 1, dtype=np.uint16)
    color_lut = np.zeros((max_label + 1, 3), dtype=np.uint8)
    color_lut[1:, 0] = ((37 * idx[1:]) % 200 + 40).astype(np.uint8)
    color_lut[1:, 1] = ((91 * idx[1:]) % 200 + 40).astype(np.uint8)
    color_lut[1:, 2] = ((151 * idx[1:]) % 200 + 40).astype(np.uint8)

    mask = labels > 0
    color_img = color_lut[labels]
    overlay = base.copy()
    overlay[mask] = (
        (base[mask].astype(np.uint16) * 6 + color_img[mask].astype(np.uint16) * 4) // 10
    ).astype(np.uint8)
    return overlay


def generate_preview(image_path: Path, output_dir: Path):
    """
    Generate a quick JPEG preview of the image for immediate display.
    Files are saved as {image_id}_preview.jpg
    """
    try:
        image_id = image_path.stem
        ext = image_path.suffix.lower()
        img = None
        
        if ext in ['.dm3', '.dm4']:
            try:
                dm = nio.read(str(image_path))
                raw_data = dm['data']
                if raw_data.ndim == 3:
                    raw_data = raw_data[0]
                norm_data = cv2.normalize(raw_data, None, 0, 255, cv2.NORM_MINMAX)
                img = norm_data.astype(np.uint8)
            except:
                pass

        if img is None and ext == '.emd':
            try:
                img = read_emd_image(image_path)
            except Exception:
                pass

        if img is None:
            # Try reading with OpenCV (works for TIFF, PNG, JPG)
            # Use IMREAD_UNCHANGED to get original depth then normalize
            img_raw = cv2.imread(str(image_path), cv2.IMREAD_UNCHANGED)
            if img_raw is not None:
                # Normalize to 8-bit for display
                if img_raw.dtype != np.uint8:
                     img = cv2.normalize(img_raw, None, 0, 255, cv2.NORM_MINMAX)
                     img = img.astype(np.uint8)
                else:
                     img = img_raw
        
        if img is not None:
            preview_path = output_dir / f"{image_id}_preview.jpg"
            cv2.imwrite(str(preview_path), img)
            return True
            
    except Exception as e:
        print(f"Error generating preview for {image_path}: {e}")
    
    return False


def _save_binary_image(output_dir: Path, image_id: str, binary: np.ndarray, suffix: str):
    filename = f"{image_id}_{suffix}.png"
    path = output_dir / filename
    binary_uint8 = (binary.astype(np.uint8) * 255)
    cv2.imwrite(str(path), binary_uint8)
    return filename


def generate_binary_mask_preview(
    image_path: Path,
    output_dir: Path,
    manual_pixel_size: float = None,
    calibration_source_path: Path = None,
    binary_mask_tune: int = 0
):
    image_id = image_path.stem
    ext = image_path.suffix.lower()
    img = None
    pixel_size_nm = None
    calibration_info = {}

    def read_dm3_pixel_size(dm3_path):
        try:
            dm = nio.read(str(dm3_path))
            if 'pixelSize' in dm:
                return float(dm['pixelSize'][0])
        except Exception as e:
            print(f"Error reading Gatan metadata: {e}")
        return None

    if calibration_source_path and calibration_source_path.exists():
        cal_ext = calibration_source_path.suffix.lower()
        if cal_ext == '.emd':
            pixel_size_nm = read_emd_pixel_size(calibration_source_path)
        else:
            pixel_size_nm = read_dm3_pixel_size(calibration_source_path)
        if pixel_size_nm:
            calibration_info = {
                "method": "linked_metadata",
                "pixel_size_nm": pixel_size_nm,
                "source_file": calibration_source_path.name,
                "description": f"Calibration: {calibration_source_path.name}"
            }

    if ext in ['.dm3', '.dm4']:
        try:
            dm = nio.read(str(image_path))
            raw_data = dm['data']
            if raw_data.ndim == 3:
                raw_data = raw_data[0]
            norm_data = cv2.normalize(raw_data, None, 0, 255, cv2.NORM_MINMAX)
            img = norm_data.astype(np.uint8)
            if pixel_size_nm is None and 'pixelSize' in dm:
                pixel_size_nm = float(dm['pixelSize'][0])
                calibration_info = {"method": "metadata_dm", "pixel_size_nm": pixel_size_nm}
        except Exception as e:
            print(f"Error reading Gatan file: {e}")
    elif ext == '.emd':
        img = read_emd_image(image_path)
        if img is not None and pixel_size_nm is None:
            emd_ps = read_emd_pixel_size(image_path)
            if emd_ps:
                pixel_size_nm = emd_ps
                calibration_info = {"method": "metadata_emd", "pixel_size_nm": pixel_size_nm}

    if img is None:
        img = cv2.imread(str(image_path), cv2.IMREAD_GRAYSCALE)

    if img is None:
        raise ValueError("Could not read image")

    if manual_pixel_size is not None and manual_pixel_size > 0:
        pixel_size_nm = manual_pixel_size
        calibration_info = {"method": "manual", "scale_bar_length_nm": "Manual"}
    elif pixel_size_nm is None:
        pixel_size_nm, calibration_info = get_pixel_size(image_path)

    if pixel_size_nm is None:
        pixel_size_nm = 1.0
        calibration_info = calibration_info or {}
        calibration_info["method"] = "uncalibrated"
        calibration_info["is_placeholder"] = True
        calibration_info.setdefault(
            "warning",
            "No calibration found. Measurements are using a placeholder scale until you calibrate manually."
        )
    else:
        calibration_info = calibration_info or {}
        calibration_info.setdefault("is_placeholder", False)

    binary_mask_tune = int(np.clip(binary_mask_tune, -6, 6))
    binary = image_kmeans(img, separation_strength=binary_mask_tune)

    if calibration_info.get("scale_bar_coords"):
        x1, y1, x2, y2 = calibration_info["scale_bar_coords"]
        h_img, w_img = binary.shape
        mask_y1 = max(0, y1 - 120)
        mask_y2 = min(h_img, y2 + 40)
        mask_x1 = max(0, x1 - 40)
        mask_x2 = min(w_img, x2 + 40)
        binary[mask_y1:mask_y2, mask_x1:mask_x2] = False

    preview_filename = _save_binary_image(output_dir, image_id, binary, "binary_preview")

    return {
        "binary_preview_url": f"/results/{preview_filename}",
        "binary_mask_tune": binary_mask_tune,
        "pixel_size_nm": pixel_size_nm,
        "calibration_info": calibration_info
    }


def process_image(
    image_path: Path,
    output_dir: Path,
    manual_pixel_size: float = None,
    calibration_source_path: Path = None,
    requested_bar_length_nm: float = None,
    binary_mask_tune: int = 0
):
    # Default to 200nm if not specified, as per user request to "have blue line as 200 nm"
    if requested_bar_length_nm is None:
        requested_bar_length_nm = 200.0

    # 1. Load Image
    image_id = image_path.stem
    ext = image_path.suffix.lower()
    img = None
    pixel_size_nm = None
    calibration_info = {}

    # Helper to read DM3 metadata
    def read_dm3_pixel_size(dm3_path):
        try:
            dm = nio.read(str(dm3_path))
            if 'pixelSize' in dm:
                return float(dm['pixelSize'][0])
        except Exception as e:
            print(f"Error reading Gatan metadata: {e}")
        return None

    # Check if we have an external calibration source (linked .dm3/.dm4/.emd file)
    if calibration_source_path and calibration_source_path.exists():
        cal_ext = calibration_source_path.suffix.lower()
        if cal_ext == '.emd':
            pixel_size_nm = read_emd_pixel_size(calibration_source_path)
        else:
            pixel_size_nm = read_dm3_pixel_size(calibration_source_path)
        if pixel_size_nm:
            calibration_info = {
                "method": "linked_metadata",
                "pixel_size_nm": pixel_size_nm,
                "source_file": calibration_source_path.name,
                "description": f"Calibration: {calibration_source_path.name}"
            }

    if ext in ['.dm3', '.dm4']:
        try:
            dm = nio.read(str(image_path))
            raw_data = dm['data']
            if raw_data.ndim == 3:
                raw_data = raw_data[0]
            norm_data = cv2.normalize(raw_data, None, 0, 255, cv2.NORM_MINMAX)
            img = norm_data.astype(np.uint8)
            if pixel_size_nm is None and 'pixelSize' in dm:
                pixel_size_nm = float(dm['pixelSize'][0])
                calibration_info = {"method": "metadata_dm", "pixel_size_nm": pixel_size_nm}
        except Exception as e:
            print(f"Error reading Gatan file: {e}")

    elif ext == '.emd':
        img = read_emd_image(image_path)
        if img is not None and pixel_size_nm is None:
            emd_ps = read_emd_pixel_size(image_path)
            if emd_ps:
                pixel_size_nm = emd_ps
                calibration_info = {"method": "metadata_emd", "pixel_size_nm": pixel_size_nm}

    if img is None:
        # Standard image load
        img = cv2.imread(str(image_path), cv2.IMREAD_GRAYSCALE)
    
    if img is None:
        raise ValueError("Could not read image")

    # 2. Get Pixel Size (Calibration) - Override or Fallback
    if manual_pixel_size is not None and manual_pixel_size > 0:
        pixel_size_nm = manual_pixel_size
        calibration_info = {"method": "manual", "scale_bar_length_nm": "Manual"}
    elif pixel_size_nm is None:
        # Try getting from utils (embedded metadata where available)
        pixel_size_nm, calibration_info = get_pixel_size(image_path)
    
    # Ensure pixel_size_nm is valid
    if pixel_size_nm is None:
        pixel_size_nm = 1.0  # Placeholder to keep pixel-domain processing alive
        calibration_info = calibration_info or {}
        calibration_info["method"] = "uncalibrated"
        calibration_info["is_placeholder"] = True
        calibration_info.setdefault(
            "warning",
            "No calibration found. Measurements are using a placeholder scale until you calibrate manually."
        )
    else:
        calibration_info = calibration_info or {}
        calibration_info.setdefault("is_placeholder", False)
    

    
    # 3. Preprocessing & Segmentation (AutoDetect-mNP)
    # User requested "Option 4": AutoDetect-mNP (K-means + rUECS)
    
    # Step 1: K-means Segmentation
    # This replaces Adaptive Thresholding
    binary_mask_tune = int(np.clip(binary_mask_tune, -6, 6))
    binary = image_kmeans(img, separation_strength=binary_mask_tune)
    
    # MASKING SCALE BAR (Fix for "detecting rods near scale")
    # image_kmeans already masks common camera footer strips; keep explicit
    # scale-bar coordinates honored when metadata/detection supplies them.
    if calibration_info.get("scale_bar_coords"):
        x1, y1, x2, y2 = calibration_info["scale_bar_coords"]
        # Mask out a slightly larger box around the line
        # The text is usually above the line.
        # Let's mask a box from y1-50 to y2+20 (approx)
        h_img, w_img = binary.shape
        
        # Safety bounds
        mask_y1 = max(0, y1 - 120) # Assume text is above (increased to 120px for large text)
        mask_y2 = min(h_img, y2 + 40) # Increased bottom margin too
        mask_x1 = max(0, x1 - 40) # Wider margin
        mask_x2 = min(w_img, x2 + 40)
        
        # Set to False (Background)
        binary[mask_y1:mask_y2, mask_x1:mask_x2] = False
    
    # Step 2: Separate Simple vs Complex objects
    labels, _ = ndi.label(binary)
    regions = measure.regionprops(labels)

    min_area_nm2 = 30
    min_size_px = max(500, int(min_area_nm2 / (pixel_size_nm * pixel_size_nm))) if pixel_size_nm else 500
    min_marker_area = max(1, min_size_px // 4)
    split_labels = np.zeros_like(labels, dtype=np.int32)
    next_label = 1

    for region in regions:
        if region.area < min_size_px:
            continue

        minr, minc, maxr, maxc = region.bbox
        label_crop = split_labels[minr:maxr, minc:maxc]

        # Solidity > 0.9 is treated as a single rod ("simple"); lower values are
        # treated as clumps and separated with a distance-transform watershed
        # (autodetect_utils.split_clump). Watershed keeps a single elongated rod
        # whole while breaking touching rods apart, and is far faster than the
        # recursive rUECS erosion it replaces.
        if region.solidity > 0.9:
            label_crop[region.image] = next_label
            next_label += 1
        else:
            split_masks = split_clump(
                region.image,
                min_marker_area,
                separation_strength=binary_mask_tune,
            )
            for d_mask in split_masks:
                label_crop[d_mask] = next_label
                next_label += 1

    labels = split_labels

    # ... (post-processing comments) ...
    
    # 5. Measurement & Filtering
    candidates = []
    output_image = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)

    # Create a mask for NMS
    occupied_mask = np.zeros(binary.shape, dtype=np.uint8)

    # Iterate labels via their bounding boxes instead of scanning the whole image
    # for every label. find_objects returns one slice per label (index = label-1),
    # so all per-object work happens on a small crop — O(total object area) rather
    # than O(n_labels x image_size).
    h_img, w_img = labels.shape
    object_slices = ndi.find_objects(labels)

    for label_idx, sl in enumerate(object_slices, start=1):
        if sl is None:
            continue

        row_slice, col_slice = sl
        minr, minc = row_slice.start, col_slice.start
        maxr, maxc = row_slice.stop, col_slice.stop

        obj_mask = (labels[row_slice, col_slice] == label_idx).astype(np.uint8)

        # Skip objects touching the image border (cannot be measured reliably).
        if ((minr == 0 and obj_mask[0, :].any()) or
                (maxr == h_img and obj_mask[-1, :].any()) or
                (minc == 0 and obj_mask[:, 0].any()) or
                (maxc == w_img and obj_mask[:, -1].any())):
            continue

        # Find contours (in crop-local coordinates).
        contours, _ = cv2.findContours(obj_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        if not contours:
            continue

        cnt_local = max(contours, key=cv2.contourArea)
        area_px = cv2.contourArea(cnt_local)

        if area_px < min_size_px:
            continue

        # Fit Rotated Rectangle (User preference for "edges")
        rect = cv2.minAreaRect(cnt_local)
        (center, (w_rect, h_rect), angle_rect) = rect

        # Normalize width/height (Length is always the longer dimension)
        if w_rect < h_rect:
            width_px = w_rect
            length_px = h_rect
            # Angle logic for minAreaRect:
            # OpenCV 4.5+: angle is in [0, 90).
            # We just want the orientation of the major axis.
            angle = angle_rect
        else:
            width_px = h_rect
            length_px = w_rect
            angle = angle_rect + 90

        if width_px == 0: continue

        # Calculate Shape Descriptors
        # 1. Area
        # area_px

        # 2. Aspect Ratio (from Rectangle)
        length_nm = length_px * pixel_size_nm
        width_nm = width_px * pixel_size_nm
        aspect_ratio = length_nm / width_nm

        # 3. Solidity = Area / Convex Area
        hull = cv2.convexHull(cnt_local)
        convex_area = cv2.contourArea(hull)
        solidity = area_px / convex_area if convex_area > 0 else 0

        # 4. Convexity = Convex Perimeter / Perimeter
        perimeter = cv2.arcLength(cnt_local, True)
        hull_perimeter = cv2.arcLength(hull, True)
        convexity = hull_perimeter / perimeter if perimeter > 0 else 0

        # 5. Circularity
        circularity = (4 * np.pi * area_px) / (perimeter ** 2) if perimeter > 0 else 0

        # 6. Eccentricity (Keep using Ellipse fit for this standard definition)
        if len(cnt_local) >= 5:
            (_, (w_ell, h_ell), _) = cv2.fitEllipse(cnt_local)
            major_axis = max(w_ell, h_ell)
            minor_axis = min(w_ell, h_ell)
            eccentricity = np.sqrt(1 - (minor_axis / major_axis) ** 2) if major_axis > 0 else 0
        else:
            eccentricity = 0

        volume_nm3 = calculate_volume(length_nm, width_nm)

        # Translate contour and centre from crop-local to full-image coordinates
        # (contour points are stored as (x, y) == (col, row)).
        offset = np.array([[[minc, minr]]], dtype=cnt_local.dtype)
        cnt = cnt_local + offset
        center = (center[0] + minc, center[1] + minr)

        candidates.append({
            "center": center,
            "size": (width_px, length_px), # Store as (W, L) for consistency, though minAreaRect is (w,h)
            "angle": angle,
            "length_nm": length_nm,
            "width_nm": width_nm,
            "aspect_ratio": aspect_ratio,
            "volume_nm3": volume_nm3,
            "area_px": area_px,
            "solidity": solidity,
            "convexity": convexity,
            "eccentricity": eccentricity,
            "circularity": circularity,
            "orientation_deg": angle,
            "bbox": (minr, minc),       # crop origin for localized NMS
            "footprint": obj_mask,      # crop-local pixel mask for NMS
            "contour": cnt              # full-image contour for coloring
        })


    # Sort candidates by Area (descending)
    candidates.sort(key=lambda x: x["area_px"], reverse=True)
    
    results = []
    
    # Non-Maximum Suppression (NMS) — dedupe overlapping detections.
    # Each candidate's footprint is compared against the occupied mask only within
    # its own bounding box, so this is O(total object area) rather than allocating
    # and scanning a full-image mask per candidate.
    for cand in candidates:
        minr, minc = cand["bbox"]
        footprint = cand["footprint"]
        fh, fw = footprint.shape

        cand_area = int(footprint.sum())
        if cand_area == 0:
            continue

        occ_window = occupied_mask[minr:minr + fh, minc:minc + fw]
        overlap = int(np.count_nonzero(footprint & occ_window))
        overlap_ratio = overlap / cand_area

        if overlap_ratio > 0.15:
            continue

        # Accept it — mark its footprint as occupied (in-place on the view).
        occ_window |= footprint

        # Add to results
        results.append({
            "id": len(results) + 1,
            "length_nm": float(round(cand["length_nm"], 1)),
            "width_nm": float(round(cand["width_nm"], 1)),
            "aspect_ratio": float(round(cand["aspect_ratio"], 1)),
            "volume_nm3": float(round(cand["volume_nm3"], 1)),
            "orientation_deg": float(round(cand["orientation_deg"], 1)),
            "centroid_x": int(cand["center"][0]),
            "centroid_y": int(cand["center"][1]),
            "area_px": int(cand["area_px"]),
            "solidity": float(round(cand["solidity"], 3)),
            "convexity": float(round(cand["convexity"], 3)),
            "circularity": float(round(cand["circularity"], 3)),
            "eccentricity": float(round(cand["eccentricity"], 3)),
            "contour": cand["contour"] # Keep for coloring
        })
        
        # Boxes and ID numbers are NOT baked into the image. The frontend draws
        # them as an interactive canvas overlay so they reflect the live
        # selection state, can be toggled off when they obscure small particles,
        # and stay crisp at any zoom. The saved image keeps only the scale bar.

    # Clean up source file name in calibration info for frontend
    def get_clean_filename(path: Path):
        name = path.name
        if len(name) > 37 and name[36] == '_':
            return name[37:]
        return name

    clean_name = get_clean_filename(image_path)
    # Removed drawing filename on image as requested
    
    # Draw Scale Bar Verification
    scale_drawn = False
    has_real_scale = bool(pixel_size_nm) and not calibration_info.get("is_placeholder")
    effective_requested_bar_nm = requested_bar_length_nm if has_real_scale else None
    
    # 0. If user requested a specific length, force synthetic bar (skip detection viz)
    if effective_requested_bar_nm:
        # Will fall through to synthetic block
        pass
    # 1. Try to draw over detected line (only if no manual override)
    elif calibration_info.get("scale_bar_coords") and has_real_scale:
        x1, y1, x2, y2 = calibration_info["scale_bar_coords"]
        
        # Calculate length if missing
        if calibration_info.get("scale_bar_length_nm") is None and pixel_size_nm:
            width_px = x2 - x1
            raw_length_nm = width_px * pixel_size_nm
            calibration_info["scale_bar_length_nm"] = int(round(raw_length_nm / 10.0)) * 10
            
        y_offset = 40
        cv2.line(output_image, (x1, y1 + y_offset), (x2, y2 + y_offset), (255, 0, 0), 5)
        
        label = f"Scale: {calibration_info['scale_bar_length_nm']} nm"
        cv2.putText(output_image, label, (x1, y1 + y_offset - 10), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 0, 0), 2)
        scale_drawn = True
        
    # 2. If no detected line OR manual override, draw synthetic bar
    if (not scale_drawn and has_real_scale) or effective_requested_bar_nm:
        h, w = output_image.shape[:2]
        
        if effective_requested_bar_nm:
            bar_length_nm = effective_requested_bar_nm
        else:
            # Choose a nice round number for the bar
            target_width_px = w * 0.2 # Target 20% of image width
            target_nm = target_width_px * pixel_size_nm
            
            # Snap to 10, 20, 50, 100, 200, 500, 1000...
            magnitude = 10 ** math.floor(math.log10(target_nm))
            residual = target_nm / magnitude
            if residual > 5:
                bar_length_nm = 5 * magnitude
            elif residual > 2:
                bar_length_nm = 2 * magnitude
            else:
                bar_length_nm = 1 * magnitude
            
        bar_width_px = int(bar_length_nm / pixel_size_nm)
        
        # Position: Bottom Left (User requested specific area, using safe bottom-left)
        x1 = 128
        if x1 + bar_width_px > w: x1 = 20 # Safety check
        x2 = x1 + bar_width_px
        y = h - 100 # Safe bottom margin
        
        cv2.line(output_image, (x1, y), (x2, y), (255, 0, 0), 10) # Thicker line
        cv2.putText(output_image, f"{int(bar_length_nm)} nm", (x1, y - 20), 
                   cv2.FONT_HERSHEY_SIMPLEX, 1.5, (255, 0, 0), 3)
        scale_drawn = True

    if not scale_drawn:
        warning_text = "Scale not calibrated" if calibration_info.get("is_placeholder") else "Scale not detected"
        cv2.putText(output_image, warning_text, (50, 100),
                   cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

    # Clean up source file name in calibration info for frontend
    if "source_file" in calibration_info:
        src_name = calibration_info["source_file"]
        if len(src_name) > 37 and src_name[36] == '_':
             calibration_info["source_file"] = src_name[37:]
             # Update description to be clean
             if "description" in calibration_info:
                 calibration_info["description"] = f"Calibration: {calibration_info['source_file']}"

    # 6. Save results
    result_image_filename = f"{image_id}_processed.jpg"
    result_image_path = output_dir / result_image_filename
    cv2.imwrite(str(result_image_path), output_image)
    
    # Save Binary Mask for debugging
    binary_filename = _save_binary_image(output_dir, image_id, binary, "binary")
    
    overlay_filename = f"{image_id}_overlay.jpg"
    overlay_path = output_dir / overlay_filename
    cv2.imwrite(str(overlay_path), _make_label_overlay(img, labels))
    
    csv_filename = f"{image_id}_results.csv"
    xlsx_filename = f"{image_id}_results.xlsx"
    csv_path = output_dir / csv_filename
    xlsx_path = output_dir / xlsx_filename

    # Save to CSV (Clean)
    df_export = pd.DataFrame(results)
    if "contour" in df_export.columns:
        df_export = df_export.drop(columns=["contour"])
    if "contour_full" in df_export.columns:
        df_export = df_export.drop(columns=["contour_full"])

    df_export.to_csv(csv_path, index=False)

    # Save to Excel (Reusable function)
    save_results_to_excel(results, xlsx_path)
    
    # Helper to sanitize values for JSON
    def sanitize(val):
        if isinstance(val, (float, np.floating)):
            if np.isnan(val) or np.isinf(val):
                return 0.0
        return val

    # Sanitize results
    sanitized_results = []
    for res in results:
        sanitized_res = {k: sanitize(v) for k, v in res.items()}
        sanitized_results.append(sanitized_res)

    # Calculate statistics
    stats = {}
    if results:
        df_res = pd.DataFrame(results)
        stats = {
            "count": len(results),
            "mean_length": sanitize(round(df_res["length_nm"].mean(), 1)),
            "std_length": sanitize(round(df_res["length_nm"].std(), 1)),
            "mean_width": sanitize(round(df_res["width_nm"].mean(), 1)),
            "std_width": sanitize(round(df_res["width_nm"].std(), 1)),
            "mean_volume": sanitize(round(df_res["volume_nm3"].mean(), 1)),
            "std_volume": sanitize(round(df_res["volume_nm3"].std(), 1)),
        }

    # Sanitize results for JSON serialization (remove numpy arrays like 'contour')
    sanitized_results = []
    for r in results:
        r_copy = r.copy()
        if "contour" in r_copy:
            del r_copy["contour"]
        # Apply general sanitization to other values
        sanitized_res_item = {k: sanitize(v) for k, v in r_copy.items()}
        sanitized_results.append(sanitized_res_item)

    output_data = {
        "results_schema_version": 6,
        "binary_mask_tune": binary_mask_tune,
        "filename": clean_name,
        "data": sanitized_results,
        "image_url": f"/results/{result_image_filename}",
        "binary_url": f"/results/{binary_filename}",
        "overlay_url": f"/results/{overlay_filename}",
        "csv_url": f"/results/{csv_filename}",
        "excel_url": f"/results/{xlsx_filename}",
        "statistics": stats,
        "pixel_size_nm": pixel_size_nm,
        "calibration_info": calibration_info,
        "filename": clean_name
    }
    
    # Save to JSON for caching
    json_path = output_dir / f"{image_id}_results.json"
    import json
    with open(json_path, 'w') as f:
        json.dump(output_data, f, indent=4)

    return output_data