Upload 3 files

README.md

@@ -1,10 +1,44 @@
----
-title: FileCompare
-emoji: 😻
-colorFrom: yellow
-colorTo: green
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Image File Compare
+emoji: 🔍
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
+sdk_version: 1.37.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🔍 Image File Compare
+
+A web-based tool for comparing two images with threshold-based difference detection.
+
+## Features
+
+- **Multi-format support** — TIFF, FITS, PNG, JPG, BMP
+- **Threshold control** — Adjustable slider to filter noise and focus on meaningful differences
+- **Auto-scaling** — When image sizes differ, automatically scales one to match (configurable method)
+- **Multiple scaling algorithms** — Nearest, Bilinear, Bicubic, Lanczos, Area
+- **Difference visualization:**
+  - Actual difference image (with optional amplification)
+  - Binary mask (white = pixels exceeding threshold)
+  - Colored overlay (red = differences)
+  - Overlay blended on original image
+- **Download outputs** — All result images downloadable as PNG or TIFF
+- **Statistics** — Pixel count, percentage, max/mean difference values
+
+## Usage
+
+1. Upload two images (supports TIF, FITS, PNG, JPG, BMP)
+2. Adjust the difference threshold in the sidebar
+3. If sizes differ, choose a scaling method and which image to resize
+4. View results: difference image, binary mask, colored overlay
+5. Download any output using the download buttons at the bottom
+
+## Running Locally
+
+```bash
+pip install -r requirements.txt
+streamlit run app.py
+```

app.py

@@ -0,0 +1,702 @@
+"""
+Image File Compare Application
+Supports TIFF, FITS and common image formats.
+Provides threshold-based difference detection with scaling options.
+Deployable on Hugging Face Spaces (Streamlit).
+"""
+
+import io
+import streamlit as st
+import numpy as np
+from PIL import Image
+from astropy.io import fits
+import cv2
+from pathlib import Path
+
+
+# --- Helper Functions ---
+
+def load_image_from_upload(uploaded_file) -> np.ndarray:
+    """Load an image from a Streamlit uploaded file object."""
+    name = uploaded_file.name.lower()
+
+    if name.endswith((".fits", ".fit", ".fts")):
+        return _load_fits_from_bytes(uploaded_file.getvalue())
+    elif name.endswith((".tif", ".tiff")):
+        return _load_tiff_from_bytes(uploaded_file.getvalue())
+    else:
+        img = Image.open(uploaded_file)
+        return np.array(img).astype(np.float64)
+
+
+def _load_fits_from_bytes(data_bytes: bytes) -> np.ndarray:
+    """Load FITS from bytes."""
+    with fits.open(io.BytesIO(data_bytes)) as hdul:
+        for hdu in hdul:
+            if hdu.data is not None:
+                data = hdu.data.astype(np.float64)
+                return _normalize_fits_data(data)
+    raise ValueError("No image data found in FITS file")
+
+
+def _normalize_fits_data(data: np.ndarray) -> np.ndarray:
+    """Normalize FITS data to 0-255 range."""
+    if data.ndim == 2:
+        dmin, dmax = np.nanmin(data), np.nanmax(data)
+        if dmax - dmin > 0:
+            data = (data - dmin) / (dmax - dmin) * 255.0
+        else:
+            data = np.zeros_like(data)
+    elif data.ndim == 3:
+        if data.shape[0] in (1, 3, 4):
+            data = np.moveaxis(data, 0, -1)
+        dmin, dmax = np.nanmin(data), np.nanmax(data)
+        if dmax - dmin > 0:
+            data = (data - dmin) / (dmax - dmin) * 255.0
+        else:
+            data = np.zeros_like(data)
+    return data
+
+
+def _load_tiff_from_bytes(data_bytes: bytes) -> np.ndarray:
+    """Load TIFF from bytes."""
+    img = Image.open(io.BytesIO(data_bytes))
+    data = np.array(img).astype(np.float64)
+    if data.max() > 255:
+        dmin, dmax = data.min(), data.max()
+        if dmax - dmin > 0:
+            data = (data - dmin) / (dmax - dmin) * 255.0
+    return data
+
+
+def align_images(img_ref: np.ndarray, img_to_align: np.ndarray,
+                 method: str = "ECC (intensity-based)") -> tuple:
+    """
+    Align img_to_align to img_ref to minimize differences.
+    Returns (aligned_image, info_dict).
+
+    Methods:
+      - "Feature-based (ORB)": Uses ORB keypoints + homography
+      - "ECC (intensity-based)": Uses Enhanced Correlation Coefficient for sub-pixel alignment
+      - "Phase correlation (translation only)": Handles pure translation/shift
+    """
+    # Convert to grayscale uint8 for alignment computation
+    def to_gray_u8(img):
+        if img.ndim == 3:
+            gray = cv2.cvtColor(img.astype(np.uint8), cv2.COLOR_RGB2GRAY)
+        else:
+            gray = img.astype(np.uint8)
+        return gray
+
+    ref_gray = to_gray_u8(img_ref)
+    align_gray = to_gray_u8(img_to_align)
+    h, w = ref_gray.shape[:2]
+
+    info = {"method": method, "success": False, "details": ""}
+
+    if method == "Feature-based (ORB)":
+        aligned, info = _align_feature_based(img_to_align, ref_gray, align_gray, h, w, info)
+    elif method == "ECC (intensity-based)":
+        aligned, info = _align_ecc(img_to_align, ref_gray, align_gray, h, w, info)
+    elif method == "Phase correlation (translation only)":
+        aligned, info = _align_phase_correlation(img_to_align, ref_gray, align_gray, h, w, info)
+    else:
+        aligned = img_to_align
+        info["details"] = "Unknown method"
+
+    return aligned, info
+
+
+def _align_feature_based(img_to_align, ref_gray, align_gray, h, w, info):
+    """Align using ORB feature detection + homography."""
+    orb = cv2.ORB_create(nfeatures=5000)
+    kp1, des1 = orb.detectAndCompute(ref_gray, None)
+    kp2, des2 = orb.detectAndCompute(align_gray, None)
+
+    if des1 is None or des2 is None or len(des1) < 10 or len(des2) < 10:
+        info["details"] = "Not enough features detected"
+        return img_to_align, info
+
+    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
+    matches = bf.knnMatch(des2, des1, k=2)
+
+    # Lowe's ratio test
+    good_matches = []
+    for m_pair in matches:
+        if len(m_pair) == 2:
+            m, n = m_pair
+            if m.distance < 0.75 * n.distance:
+                good_matches.append(m)
+
+    if len(good_matches) < 10:
+        info["details"] = f"Only {len(good_matches)} good matches found (need >= 10)"
+        return img_to_align, info
+
+    src_pts = np.float32([kp2[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+    dst_pts = np.float32([kp1[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
+
+    M, mask_inliers = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
+
+    if M is None:
+        info["details"] = "Homography estimation failed"
+        return img_to_align, info
+
+    inliers = int(mask_inliers.sum()) if mask_inliers is not None else 0
+    info["success"] = True
+    info["details"] = f"{len(good_matches)} matches, {inliers} inliers"
+
+    if img_to_align.ndim == 2:
+        aligned = cv2.warpPerspective(img_to_align, M, (w, h),
+                                      flags=cv2.INTER_LINEAR,
+                                      borderMode=cv2.BORDER_REFLECT)
+    else:
+        aligned = cv2.warpPerspective(img_to_align, M, (w, h),
+                                      flags=cv2.INTER_LINEAR,
+                                      borderMode=cv2.BORDER_REFLECT)
+
+    return aligned, info
+
+
+def _align_ecc(img_to_align, ref_gray, align_gray, h, w, info):
+    """Align using Enhanced Correlation Coefficient (ECC) — handles rotation + translation."""
+    # Use affine (6 DOF: rotation, translation, scale, shear)
+    warp_matrix = np.eye(2, 3, dtype=np.float32)
+
+    criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 200, 1e-6)
+
+    try:
+        # Downscale for initial estimate if images are large
+        scale = 1.0
+        if max(h, w) > 1000:
+            scale = 500.0 / max(h, w)
+            ref_small = cv2.resize(ref_gray, None, fx=scale, fy=scale)
+            align_small = cv2.resize(align_gray, None, fx=scale, fy=scale)
+
+            warp_small = np.eye(2, 3, dtype=np.float32)
+            _, warp_small = cv2.findTransformECC(
+                ref_small, align_small, warp_small, cv2.MOTION_AFFINE, criteria
+            )
+
+            # Scale the translation back
+            warp_matrix = warp_small.copy()
+            warp_matrix[0, 2] /= scale
+            warp_matrix[1, 2] /= scale
+
+        # Refine at full resolution
+        _, warp_matrix = cv2.findTransformECC(
+            ref_gray, align_gray, warp_matrix, cv2.MOTION_AFFINE, criteria
+        )
+
+        info["success"] = True
+        # Extract rotation angle from the matrix
+        angle = np.degrees(np.arctan2(warp_matrix[1, 0], warp_matrix[0, 0]))
+        tx, ty = warp_matrix[0, 2], warp_matrix[1, 2]
+        info["details"] = f"Rotation: {angle:.3f}°, Translation: ({tx:.1f}, {ty:.1f}) px"
+
+    except cv2.error as e:
+        info["details"] = f"ECC failed to converge: {str(e)}"
+        return img_to_align, info
+
+    if img_to_align.ndim == 2:
+        aligned = cv2.warpAffine(img_to_align, warp_matrix, (w, h),
+                                 flags=cv2.INTER_LINEAR,
+                                 borderMode=cv2.BORDER_REFLECT)
+    else:
+        aligned = cv2.warpAffine(img_to_align, warp_matrix, (w, h),
+                                 flags=cv2.INTER_LINEAR,
+                                 borderMode=cv2.BORDER_REFLECT)
+
+    return aligned, info
+
+
+def _align_phase_correlation(img_to_align, ref_gray, align_gray, h, w, info):
+    """Align using phase correlation — handles pure translation/shift."""
+    ref_f = ref_gray.astype(np.float32)
+    align_f = align_gray.astype(np.float32)
+
+    shift, response = cv2.phaseCorrelate(ref_f, align_f)
+
+    tx, ty = shift  # (x, y) shift
+    info["success"] = True
+    info["details"] = f"Translation: ({tx:.2f}, {ty:.2f}) px, confidence: {response:.4f}"
+
+    M = np.float32([[1, 0, tx], [0, 1, ty]])
+
+    if img_to_align.ndim == 2:
+        aligned = cv2.warpAffine(img_to_align, M, (w, h),
+                                 flags=cv2.INTER_LINEAR,
+                                 borderMode=cv2.BORDER_REFLECT)
+    else:
+        aligned = cv2.warpAffine(img_to_align, M, (w, h),
+                                 flags=cv2.INTER_LINEAR,
+                                 borderMode=cv2.BORDER_REFLECT)
+
+    return aligned, info
+
+
+def resize_image(image: np.ndarray, target_shape: tuple, method: str) -> np.ndarray:
+    """Resize image to target shape using specified interpolation method."""
+    interpolation_methods = {
+        "Nearest": cv2.INTER_NEAREST,
+        "Bilinear": cv2.INTER_LINEAR,
+        "Bicubic": cv2.INTER_CUBIC,
+        "Lanczos": cv2.INTER_LANCZOS4,
+        "Area": cv2.INTER_AREA,
+    }
+    interp = interpolation_methods.get(method, cv2.INTER_LINEAR)
+    target_h, target_w = target_shape[:2]
+    resized = cv2.resize(image, (target_w, target_h), interpolation=interp)
+    return resized
+
+
+def compute_difference(img1: np.ndarray, img2: np.ndarray, threshold: float):
+    """
+    Compute difference between two images.
+    Returns:
+        diff_image: absolute difference (float64)
+        mask_image: binary mask where diff > threshold (uint8, 0 or 255)
+        stats: dictionary with comparison statistics
+    """
+    img1_proc = img1.copy()
+    img2_proc = img2.copy()
+
+    # Strip alpha channel if present
+    if img1_proc.ndim == 3 and img1_proc.shape[2] == 4:
+        img1_proc = img1_proc[:, :, :3]
+    if img2_proc.ndim == 3 and img2_proc.shape[2] == 4:
+        img2_proc = img2_proc[:, :, :3]
+
+    # If one is grayscale and other is color, convert both to grayscale
+    if img1_proc.ndim != img2_proc.ndim:
+        if img1_proc.ndim == 3:
+            img1_proc = cv2.cvtColor(img1_proc.astype(np.uint8), cv2.COLOR_RGB2GRAY).astype(np.float64)
+        if img2_proc.ndim == 3:
+            img2_proc = cv2.cvtColor(img2_proc.astype(np.uint8), cv2.COLOR_RGB2GRAY).astype(np.float64)
+
+    diff = np.abs(img1_proc - img2_proc)
+
+    # For multi-channel, take the max across channels for the mask
+    if diff.ndim == 3:
+        diff_for_mask = np.max(diff, axis=2)
+    else:
+        diff_for_mask = diff
+
+    mask = (diff_for_mask > threshold).astype(np.uint8) * 255
+
+    # Statistics
+    total_pixels = mask.shape[0] * mask.shape[1]
+    diff_pixels = int(np.count_nonzero(mask))
+    diff_percentage = (diff_pixels / total_pixels) * 100
+
+    stats = {
+        "total_pixels": total_pixels,
+        "different_pixels": diff_pixels,
+        "difference_percentage": diff_percentage,
+        "max_difference": float(np.max(diff)),
+        "mean_difference": float(np.mean(diff)),
+    }
+
+    return diff, mask, stats
+
+
+def to_display_image(data: np.ndarray) -> np.ndarray:
+    """Convert array to displayable uint8 image."""
+    if data.ndim == 2:
+        dmin, dmax = data.min(), data.max()
+        if dmax - dmin > 0:
+            normalized = ((data - dmin) / (dmax - dmin) * 255).astype(np.uint8)
+        else:
+            normalized = np.zeros_like(data, dtype=np.uint8)
+        return normalized
+    else:
+        return np.clip(data, 0, 255).astype(np.uint8)
+
+
+def create_colored_mask(mask: np.ndarray, diff: np.ndarray) -> np.ndarray:
+    """Create a colored overlay showing differences.
+    Green = no difference, Red = difference detected."""
+    h, w = mask.shape[:2]
+    colored = np.zeros((h, w, 3), dtype=np.uint8)
+    colored[:, :, 1] = 100  # slight green background
+
+    if diff.ndim == 3:
+        diff_gray = np.max(diff, axis=2)
+    else:
+        diff_gray = diff
+
+    diff_normalized = np.clip(diff_gray / max(diff_gray.max(), 1) * 255, 0, 255).astype(np.uint8)
+
+    colored[mask > 0, 0] = 255
+    colored[mask > 0, 1] = 0
+    colored[mask > 0, 2] = diff_normalized[mask > 0]
+
+    return colored
+
+
+def image_to_png_bytes(img_array: np.ndarray) -> bytes:
+    """Convert numpy array to PNG bytes for download."""
+    img = Image.fromarray(img_array)
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def image_to_tiff_bytes(img_array: np.ndarray) -> bytes:
+    """Convert numpy array to TIFF bytes for download."""
+    img = Image.fromarray(img_array)
+    buf = io.BytesIO()
+    img.save(buf, format="TIFF")
+    return buf.getvalue()
+
+
+# --- Streamlit App ---
+
+def main():
+    st.set_page_config(page_title="Image Compare Tool", layout="wide")
+    st.title("🔍 Image File Compare")
+    st.markdown("Compare two images with threshold-based difference detection. "
+                "Supports **TIFF**, **FITS**, and common image formats.")
+
+    # --- Sidebar Controls ---
+    st.sidebar.header("⚙️ Settings")
+
+    threshold = st.sidebar.slider(
+        "Difference Threshold",
+        min_value=0.0,
+        max_value=255.0,
+        value=10.0,
+        step=0.5,
+        help="Pixel differences below this threshold are ignored."
+    )
+
+    scaling_method = st.sidebar.selectbox(
+        "Scaling Method (if sizes differ)",
+        ["Bilinear", "Nearest", "Bicubic", "Lanczos", "Area"],
+        help="Interpolation method used when resizing images to match dimensions."
+    )
+
+    scale_target = st.sidebar.radio(
+        "Scale which image?",
+        ["Scale Image 2 to match Image 1", "Scale Image 1 to match Image 2"],
+        help="Choose which image gets resized when dimensions differ."
+    )
+
+    st.sidebar.markdown("---")
+    st.sidebar.header("🔄 Auto-Alignment")
+
+    enable_alignment = st.sidebar.checkbox(
+        "Enable auto-alignment",
+        value=False,
+        help="Automatically align Image 2 to Image 1 to compensate for rotation/translation before comparison."
+    )
+
+    alignment_method = "ECC (intensity-based)"
+    if enable_alignment:
+        alignment_method = st.sidebar.selectbox(
+            "Alignment method",
+            ["ECC (intensity-based)", "Feature-based (ORB)", "Phase correlation (translation only)"],
+            help="ECC: best for small rotations/shifts (sub-pixel). "
+                 "ORB: best for larger rotations with texture. "
+                 "Phase correlation: translation/shift only."
+        )
+
+    st.sidebar.markdown("---")
+    st.sidebar.header("📊 Display Options")
+
+    show_enhanced_diff = st.sidebar.checkbox("Enhanced difference (amplified)", value=True,
+                                             help="Amplify small differences for better visibility.")
+    amplify_factor = 1.0
+    if show_enhanced_diff:
+        amplify_factor = st.sidebar.slider("Amplification factor", 1.0, 50.0, 10.0, 1.0)
+
+    st.sidebar.markdown("---")
+    st.sidebar.header("💾 Download Format")
+    download_format = st.sidebar.selectbox("Output format", ["PNG", "TIFF"])
+
+    # --- Help & Credits ---
+    st.sidebar.markdown("---")
+
+    @st.dialog("📖 Help — Image File Compare", width="large")
+    def show_help():
+        st.markdown("""
+## Overview
+
+**Image File Compare** is a tool designed for **astronomical image comparison**. It helps astronomers and astrophotographers compare star field images captured by different telescopes, at different times, or with different processing pipelines.
+
+By overlaying and differencing two images of the same region of sky, you can identify:
+- **New or missing objects** (transients, variable stars, asteroids, novae)
+- **Alignment/registration errors** between exposures
+- **Processing artifacts** introduced by different reduction pipelines
+- **Changes over time** in stellar fields (proper motion, variability)
+
+---
+
+## Parameters & Settings
+
+### Difference Threshold (0–255)
+Controls the sensitivity of the comparison. Pixel-level differences **below** this value are treated as "no change" and ignored.
+- **Low threshold (0–5):** Very sensitive — shows noise-level differences, sensor read noise, and thermal artifacts.
+- **Medium threshold (5–20):** Good default — filters out minor noise while catching real changes.
+- **High threshold (20+):** Only shows large differences — useful for finding bright transients or major changes.
+
+### Scaling Method
+When two images have **different pixel dimensions** (e.g., different instruments or plate scales), one image must be resized to match. Choose the interpolation method:
+- **Bilinear:** Good general-purpose method. Fast, smooth results.
+- **Nearest:** No interpolation — preserves exact pixel values. Best for integer data.
+- **Bicubic:** Smoother than bilinear. Slightly sharper results.
+- **Lanczos:** Highest quality. Best for downsampling. Preserves fine detail.
+- **Area:** Best for shrinking images. Uses pixel area relation.
+
+### Scale Which Image?
+Choose which image gets resized when dimensions differ. Typically you keep your **reference image** (Image 1) at its native resolution and scale Image 2 to match.
+
+---
+
+## Auto-Alignment
+
+When images have rotational or translational offsets (common when comparing across different telescopes, mounts, or epochs), enable auto-alignment to register Image 2 to Image 1 before comparison.
+
+### Alignment Methods
+
+- **ECC (intensity-based):** Enhanced Correlation Coefficient method. Works by maximizing the correlation between pixel intensities. Best for **small rotations** (< 5°) and sub-pixel translations. Very accurate but can fail on large offsets.
+
+- **Feature-based (ORB):** Detects keypoint features (stars, galaxies) in both images and matches them to compute a geometric transform (homography). Best for **larger rotations** and images with many point sources. Works well for star fields.
+
+- **Phase correlation (translation only):** Computes the translational shift between images using Fourier analysis. Only corrects X/Y offset — does **not** handle rotation. Very fast, good for dithered exposures from the same telescope.
+
+---
+
+## Display Options
+
+### Enhanced Difference (Amplified)
+When enabled, the difference image is multiplied by an amplification factor to make subtle differences visible. Without this, a 1-count difference on a 0–255 scale would be nearly invisible.
+
+### Amplification Factor (1–50×)
+How much to boost the difference image. Higher values make faint differences more visible but can saturate bright differences.
+
+---
+
+## Download Format
+Choose whether output images are saved as:
+- **PNG:** Lossless, 8-bit per channel. Compatible with all viewers.
+- **TIFF:** Lossless, widely used in astronomical imaging pipelines.
+
+---
+
+## Output Images
+
+- **Actual Difference Image:** Absolute pixel-by-pixel difference between the two images (optionally amplified).
+- **Binary Mask:** White pixels where the difference exceeds the threshold, black elsewhere. Useful for counting changed regions.
+- **Colored Difference Overlay:** Red marks pixels exceeding the threshold, dark green shows matching regions. Intensity indicates the magnitude of difference.
+- **Overlay on Original:** The colored overlay blended onto Image 1 at adjustable opacity, helping you localize differences in context.
+""")
+
+    if st.sidebar.button("❓ Help", use_container_width=True):
+        show_help()
+
+    st.sidebar.markdown("---")
+    st.sidebar.markdown(
+        "<div style='text-align: center; color: gray; font-size: 0.85em;'>"
+        "Created by <b>Andy Kong</b>"
+        "</div>",
+        unsafe_allow_html=True,
+    )
+
+    # --- Image Input ---
+    st.header("📁 Upload Images")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        file1 = st.file_uploader("Image 1", type=["tif", "tiff", "fits", "fit", "fts",
+                                                    "png", "jpg", "jpeg", "bmp"])
+    with col2:
+        file2 = st.file_uploader("Image 2", type=["tif", "tiff", "fits", "fit", "fts",
+                                                    "png", "jpg", "jpeg", "bmp"])
+
+    img1_data = None
+    img2_data = None
+    img1_name = ""
+    img2_name = ""
+
+    if file1 and file2:
+        img1_name = file1.name
+        img2_name = file2.name
+        try:
+            img1_data = load_image_from_upload(file1)
+            img2_data = load_image_from_upload(file2)
+        except Exception as e:
+            st.error(f"Error loading images: {e}")
+
+    # --- Comparison ---
+    if img1_data is not None and img2_data is not None:
+        st.markdown("---")
+        st.header("📐 Image Information")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            st.markdown(f"**Image 1:** `{img1_name}`")
+            st.markdown(f"Shape: `{img1_data.shape}` | "
+                        f"Range: [{img1_data.min():.1f}, {img1_data.max():.1f}]")
+        with col2:
+            st.markdown(f"**Image 2:** `{img2_name}`")
+            st.markdown(f"Shape: `{img2_data.shape}` | "
+                        f"Range: [{img2_data.min():.1f}, {img2_data.max():.1f}]")
+
+        # Handle size mismatch
+        if img1_data.shape[:2] != img2_data.shape[:2]:
+            st.warning(f"⚠️ Image sizes differ! Image 1: {img1_data.shape[:2]}, "
+                       f"Image 2: {img2_data.shape[:2]}. "
+                       f"Applying **{scaling_method}** scaling.")
+
+            if "Image 2" in scale_target:
+                img2_data = resize_image(img2_data, img1_data.shape[:2], scaling_method)
+            else:
+                img1_data = resize_image(img1_data, img2_data.shape[:2], scaling_method)
+
+        # Handle channel mismatch
+        if img1_data.ndim != img2_data.ndim:
+            st.info("Channel mismatch detected. Converting both to grayscale for comparison.")
+            if img1_data.ndim == 3:
+                img1_data = cv2.cvtColor(img1_data.astype(np.uint8),
+                                         cv2.COLOR_RGB2GRAY).astype(np.float64)
+            if img2_data.ndim == 3:
+                img2_data = cv2.cvtColor(img2_data.astype(np.uint8),
+                                         cv2.COLOR_RGB2GRAY).astype(np.float64)
+
+        # Auto-alignment
+        if enable_alignment:
+            with st.spinner(f"Aligning images using {alignment_method}..."):
+                img2_data, align_info = align_images(img1_data, img2_data, alignment_method)
+            if align_info["success"]:
+                st.success(f"✅ Alignment successful — {align_info['details']}")
+            else:
+                st.warning(f"⚠️ Alignment issue — {align_info['details']}")
+
+        # Compute difference
+        diff, mask, stats = compute_difference(img1_data, img2_data, threshold)
+
+        # --- Results ---
+        st.markdown("---")
+        st.header("📊 Comparison Results")
+
+        # Stats
+        stat_cols = st.columns(4)
+        stat_cols[0].metric("Different Pixels", f"{stats['different_pixels']:,}")
+        stat_cols[1].metric("Difference %", f"{stats['difference_percentage']:.2f}%")
+        stat_cols[2].metric("Max Difference", f"{stats['max_difference']:.1f}")
+        stat_cols[3].metric("Mean Difference", f"{stats['mean_difference']:.2f}")
+
+        # Determine download format
+        if download_format == "PNG":
+            ext = "png"
+            mime = "image/png"
+            convert_fn = image_to_png_bytes
+        else:
+            ext = "tiff"
+            mime = "image/tiff"
+            convert_fn = image_to_tiff_bytes
+
+        st.markdown("---")
+
+        # Display images
+        st.subheader("🖼️ Source Images")
+        col1, col2 = st.columns(2)
+        with col1:
+            st.markdown(f"**Image 1:** `{img1_name}`")
+            st.image(to_display_image(img1_data), use_container_width=True)
+        with col2:
+            st.markdown(f"**Image 2:** `{img2_name}`")
+            st.image(to_display_image(img2_data), use_container_width=True)
+
+        st.markdown("---")
+
+        # Prepare output images
+        diff_display = diff.copy()
+        if show_enhanced_diff:
+            diff_display = diff_display * amplify_factor
+        diff_display_uint8 = to_display_image(diff_display)
+        mask_display = mask  # already uint8
+
+        # --- Difference Image with inline download ---
+        header_col, btn_col = st.columns([4, 1])
+        with header_col:
+            st.subheader("🔎 Actual Difference Image")
+        with btn_col:
+            st.download_button(
+                label=f"⬇️ .{ext}",
+                data=convert_fn(diff_display_uint8),
+                file_name=f"difference.{ext}",
+                mime=mime,
+                key="dl_diff",
+            )
+        st.image(diff_display_uint8, use_container_width=True)
+
+        st.markdown("---")
+
+        # --- Binary Mask with inline download ---
+        header_col, btn_col = st.columns([4, 1])
+        with header_col:
+            st.subheader("🎭 Binary Mask")
+        with btn_col:
+            st.download_button(
+                label=f"⬇️ .{ext}",
+                data=convert_fn(mask_display),
+                file_name=f"mask.{ext}",
+                mime=mime,
+                key="dl_mask",
+            )
+        st.image(mask_display, use_container_width=True,
+                 caption="White = difference > threshold")
+
+        st.markdown("---")
+
+        # --- Colored Overlay with inline download ---
+        colored_mask = create_colored_mask(mask, diff)
+        header_col, btn_col = st.columns([4, 1])
+        with header_col:
+            st.subheader("🎨 Colored Difference Overlay")
+        with btn_col:
+            st.download_button(
+                label=f"⬇️ .{ext}",
+                data=convert_fn(colored_mask),
+                file_name=f"colored_overlay.{ext}",
+                mime=mime,
+                key="dl_colored",
+            )
+        st.image(colored_mask, use_container_width=True,
+                 caption="Red = pixels exceeding threshold | Dark green = within threshold")
+
+        st.markdown("---")
+
+        # --- Overlay on Original with inline download ---
+        overlay_alpha = st.slider("Overlay opacity", 0.0, 1.0, 0.4, 0.05)
+
+        base_img = to_display_image(img1_data)
+        if base_img.ndim == 2:
+            base_img = cv2.cvtColor(base_img, cv2.COLOR_GRAY2RGB)
+        elif base_img.ndim == 3 and base_img.shape[2] == 4:
+            base_img = cv2.cvtColor(base_img, cv2.COLOR_RGBA2RGB)
+
+        overlay = cv2.addWeighted(base_img, 1 - overlay_alpha,
+                                  colored_mask, overlay_alpha, 0)
+
+        header_col, btn_col = st.columns([4, 1])
+        with header_col:
+            st.subheader("📷 Overlay on Original")
+        with btn_col:
+            st.download_button(
+                label=f"⬇️ .{ext}",
+                data=convert_fn(overlay),
+                file_name=f"overlay_on_original.{ext}",
+                mime=mime,
+                key="dl_overlay",
+            )
+        st.image(overlay, use_container_width=True,
+                 caption="Image 1 with difference overlay")
+
+    else:
+        st.info("👆 Please upload two images to compare.")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,5 @@
+streamlit==1.37.0
+numpy==1.26.4
+Pillow==10.4.0
+astropy==6.1.1
+opencv-python-headless==4.10.0.84