app.py

'''
This is the originall CLL Explorer application that allows users to upload, process, and save images.

The application provides the following functionalities:
- Upload microscope images.
- Adjust image view with zoom and enhancement controls.
- Detect and measure cells automatically.
- Save analysis results and annotations.

The application is divided into the following sections:
1. **Upload Images**: Users can upload microscope images in JPG or PNG format.
2. **Select Image**: Users can select an image from the uploaded files.
3. **Processed Image**: Displays the processed image with zoom and enhancement controls.
4. **Image Controls**: Allows users to adjust the image view with sliders for X and Y coordinates, zoom, contrast, brightness, and sharpness.
5. **Save Options**: Provides options to save the processed image, image description, and image parameters.

To run the application:
1. Save the script in a Python file (e.g., app.py).
2. Run the script using the Streamlit command:
```bash
streamlit run app.py

'''

import streamlit as st
from PIL import Image, ImageEnhance
import pandas as pd
import numpy as np
import io
import os
import tempfile
import zipfile
import cv2
import numpy as np

def zoom_at(img, x, y, zoom):
    '''
    Zoom into an image at a specific location.

    Parameters:
    ----------
    img : PIL.Image
        Input image.

    x : int
        X-coordinate of the zoom center.

    y : int
        Y-coordinate of the zoom center.

    zoom : float
        Zoom factor.

    Returns:
    -------
    PIL.Image
        Zoomed image resized to 500x500 pixels.
    '''
    w, h = img.size
    zoom_half = zoom / 2
    left = max(x - w * zoom_half, 0)
    upper = max(y - h * zoom_half, 0)
    right = min(x + w * zoom_half, w)
    lower = min(y + h * zoom_half, h)
    img_cropped = img.crop((left, upper, right, lower))
    return img_cropped.resize((500, 500), Image.LANCZOS)

@st.cache_data
def apply_enhancements(img, x, y, zoom, contrast, brightness, sharpness):
    '''
    Apply zoom and image enhancements to the input image.

    Parameters:
    ----------
    img : PIL.Image
        Input image.
    x : int
        X-coordinate of the zoom center.
    y : int
        Y-coordinate of the zoom center.
    zoom : float
        Zoom factor.
    contrast : float
        Contrast adjustment factor.
    brightness : float
        Brightness adjustment factor.
    sharpness : float
        Sharpness adjustment factor.

    Returns:
    -------
    PIL.Image
        Enhanced image resized to 500x500 pixels.
    '''
    zoomed = zoom_at(img, x, y, zoom)
    enhanced_contrast = ImageEnhance.Contrast(zoomed).enhance(contrast)
    enhanced_brightness = ImageEnhance.Brightness(enhanced_contrast).enhance(brightness)
    enhanced_sharpness = ImageEnhance.Sharpness(enhanced_brightness).enhance(sharpness)
    return enhanced_sharpness

def apply_enhancements_cv(img, x, y, zoom, contrast, brightness, sharpness):
    """
    Use OpenCV for zoom and enhancements.
    """
    # Convert PIL to OpenCV format
    img_cv = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
    h, w = img_cv.shape[:2]

    # Zoom
    zoom_half = int(zoom / 2)
    left = max(x - w * zoom_half, 0)
    top = max(y - h * zoom_half, 0)
    right = min(x + w * zoom_half, w)
    bottom = min(y + h * zoom_half, h)
    cropped = img_cv[int(top):int(bottom), int(left):int(right)]
    resized = cv2.resize(cropped, (500, 500), interpolation=cv2.INTER_LANCZOS4)

    # Convert back to PIL for other enhancements
    pil_img = Image.fromarray(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB))
    enhanced_contrast = ImageEnhance.Contrast(pil_img).enhance(contrast)
    enhanced_brightness = ImageEnhance.Brightness(enhanced_contrast).enhance(brightness)
    enhanced_sharpness = ImageEnhance.Sharpness(enhanced_brightness).enhance(sharpness)
    return enhanced_sharpness

def create_zip(processed_img, description, params):
    '''
    Create a zip archive containing the processed image and annotations.

    Parameters:
    ----------
    processed_img : PIL.Image
        The processed image.
    description : str
        Description of the image.
    params : dict
        Image parameters.

    Returns:
    -------
    bytes
        Byte content of the zip file.
    '''
    with tempfile.TemporaryDirectory() as tmpdirname:
        img_path = os.path.join(tmpdirname, "processed_image.jpg")
        desc_path = os.path.join(tmpdirname, "description.txt")
        params_path = os.path.join(tmpdirname, "parameters.json")

        # Save processed image
        processed_img.save(img_path)

        # Save description
        with open(desc_path, "w") as f:
            f.write(description)

        # Save parameters
        pd.DataFrame([params]).to_json(params_path, orient="records")

        # Create zip
        zip_buffer = io.BytesIO()
        with zipfile.ZipFile(zip_buffer, "w") as zipf:
            zipf.write(img_path, arcname="processed_image.jpg")
            zipf.write(desc_path, arcname="description.txt")
            zipf.write(params_path, arcname="parameters.json")

        zip_buffer.seek(0)
        return zip_buffer

# Streamlit App Configuration
st.set_page_config(page_title="CLL Explorer", layout="wide")
st.title("CLL Explorer: Cell Image Analysis Prep Tool")

st.markdown("""
### About This Application
This tool assists researchers in analyzing microscope images of any cell type.
- **Upload** microscope images.
- **Adjust** image view with zoom and enhancement controls.
- **Detect** and measure cells automatically.
- **Save** analysis results and annotations.
""")

uploaded_files = st.file_uploader("Upload Images", accept_multiple_files=True, type=["jpg", "png"])

if uploaded_files:
    img_index = st.selectbox(
        "Select Image",
        range(len(uploaded_files)),
        format_func=lambda x: uploaded_files[x].name
    )
    img_data = uploaded_files[img_index].read()
    img = Image.open(io.BytesIO(img_data)).convert("RGB").resize((500, 500))

    # Create columns with image on the left and controls on the right
    image_col, controls_col = st.columns([3, 1])

    with image_col:
        st.subheader("Processed Image")
        if 'processed_img' in st.session_state:
            st.image(st.session_state.processed_img, use_column_width=True, caption="Processed Image")
        else:
            st.image(img, use_column_width=True, caption="Processed Image")

    with controls_col:
        st.subheader("Image Controls")
        x = st.slider("X Coordinate", 0, 500, 250)
        y = st.slider("Y Coordinate", 0, 500, 250)
        zoom = st.slider("Zoom", 1.0, 10.0, 5.0, step=0.1)

        with st.expander("Enhancement Settings", expanded=True):
            contrast = st.slider("Contrast", 0.0, 5.0, 1.0, step=0.1)
            brightness = st.slider("Brightness", 0.0, 5.0, 1.0, step=0.1)
            sharpness = st.slider("Sharpness", 0.0, 2.0, 1.0, step=0.1)

        if st.button("Apply Adjustments"):
            processed_img = apply_enhancements(img, x, y, zoom, contrast, brightness, sharpness)
            st.session_state.processed_img = processed_img

    # Display Original Image Below
    st.subheader("Original Image")
    st.image(img, use_column_width=True, caption="Original Image")

    # Save and Export Options
    st.markdown("---")
    st.subheader("Save and Export Options")

    with st.expander("Add Annotations", expanded=True):
        description = st.text_area("Describe the image", "")
        params = {
            "coordinates_x": x,
            "coordinates_y": y,
            "zoom": zoom,
            "contrast": contrast,
            "brightness": brightness,
            "sharpness": sharpness
        }

    if st.button("Prepare Download"):
        if 'processed_img' in st.session_state and description:
            zip_buffer = create_zip(st.session_state.processed_img, description, params)
            st.download_button(
                label="Download Zip",
                data=zip_buffer,
                file_name="processed_image_and_annotations.zip",
                mime="application/zip"
            )
            st.success("Zip file is ready for download.")
        else:
            st.warning("Ensure that the processed image is available and description is provided.")

    # Optional: Save Processed Image Locally
    save_image = st.checkbox("Save Processed Image Locally")
    if save_image:
        if 'processed_img' in st.session_state:
            processed_img_path = os.path.join("processed_image_500x500.jpg")
            st.session_state.processed_img.save(processed_img_path)
            st.success(f"Image saved as `{processed_img_path}`")
        else:
            st.warning("No processed image to save.")

    # Optional: Rename Files
    if st.button("Rename Files"):
        if 'processed_img' in st.session_state:
            file_ext = str(np.random.randint(100))
            new_img_name = f"img_processed_{file_ext}.jpg"
            processed_img_path = "processed_image_500x500.jpg"
            if os.path.exists(processed_img_path):
                os.rename(processed_img_path, new_img_name)

            # Save parameters and description
            params_path = f"parameters_{file_ext}.json"
            description_path = f"description_{file_ext}.txt"

            pd.DataFrame([params]).to_json(params_path, orient="records")
            with open(description_path, "w") as f:
                f.write(description)

            st.success(f"Files renamed to `{new_img_name}`, `{params_path}`, and `{description_path}`")
        else:
            st.warning("No processed image to rename.")