app.py

import gradio as gr
import cv2
import numpy as np
#from imagesFunctions import *

# Define preprocessing functions
def grayscale(image):
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    return gray_image

def blur(image):
    blurred_image = cv2.GaussianBlur(image, (15, 15), 0)
    return blurred_image

def edge_detection(image):
    edges = cv2.Canny(image, 100, 200)
    return edges

def invert_colors(image):
    inverted_image = cv2.bitwise_not(image)
    return inverted_image

def threshold(image):
    _, thresh_image = cv2.threshold(image, 128, 255, cv2.THRESH_BINARY)
    return thresh_image

def gray_level_transform(image, alpha=1.0, beta=0.0):
    """
    Apply a simple gray level transformation to the image.
    Formula: new_intensity = alpha * old_intensity + beta
    """
    transformed_image = cv2.convertScaleAbs(image, alpha=alpha, beta=beta)
    return transformed_image

def negative_transform(image):
    """
    Apply a negative transformation to the image.
    """
    negative_image = 255 - image  # Invert pixel values
    return negative_image

def log_transform(image, c=1):
    """
    Apply a logarithmic transformation to the image.
    """
    log_image = np.log1p(c * image)  # Apply log transformation
    # Scale the values to the range [0, 255]
    log_image = (log_image / np.max(log_image)) * 255
    log_image = np.uint8(log_image)
    return log_image

def power_law_transform(image, gamma=1.0):
    """
    Apply a power law transformation (gamma correction) to the image.
    """
    # Apply gamma correction
    power_law_image = np.power(image / 255.0, gamma)
    # Scale the values back to the range [0, 255]
    power_law_image = np.uint8(power_law_image * 255)
    return power_law_image

def contrast_stretching(image, low=0, high=255):
    """
    Stretch the contrast of an image by mapping pixel values to a new range.

    Args:
        image: A numpy array representing the image.
        low: The minimum value in the output image (default: 0).
        high: The maximum value in the output image (default: 255).

    Returns:
        A numpy array representing the contrast-stretched image.
    """
    # Find the minimum and maximum values in the image
    min_val = np.amin(image)
    max_val = np.amax(image)

    # Check if min and max are the same (no stretch needed)
    if min_val == max_val:
        return image

    # Normalize the pixel values to the range [0, 1]
    normalized = (image - min_val) / (max_val - min_val)

    # Stretch the normalized values to the new range [low, high]
    stretched = normalized * (high - low) + low

    # Convert the stretched values back to the original data type (uint8 for images)
    return np.uint8(stretched * 255)


def intensity_slicing(image, threshold):
    """
    Perform intensity slicing on an image to create a binary image.

    Args:
        image: A numpy array representing the image.
        threshold: The intensity threshold for binarization (default: 128).

    Returns:
        A numpy array representing the binary image after intensity slicing.
    """
    # Create a copy of the image to avoid modifying the original
    sliced_image = image.copy()

    # Apply thresholding
    sliced_image[sliced_image > threshold] = 255  # Set values above threshold to white (255)
    sliced_image[sliced_image <= threshold] = 0  # Set values below or equal to threshold to black (0)

    return sliced_image

def histogram_equalization(image):
    """
    Perform histogram equalization on an image to enhance its contrast.

    Args:
        image: A numpy array representing the image.

    Returns:
        A numpy array representing the image after histogram equalization.
    """
    # Compute histogram of the input image
    hist, _ = np.histogram(image.flatten(), bins=256, range=(0,256))

    # Compute cumulative distribution function (CDF)
    cdf = hist.cumsum()

    # Normalize CDF
    cdf_normalized = cdf * hist.max() / cdf.max()

    # Perform histogram equalization
    equalized_image = np.interp(image.flatten(), range(256), cdf_normalized).reshape(image.shape)

    return equalized_image.astype(np.uint8)


def mean_filter(image, kernel_size=3):
    """
    Apply a mean filter (averaging filter) to the image.

    Args:
        image: A numpy array representing the input image.
        kernel_size: The size of the square kernel (default: 3).

    Returns:
        A numpy array representing the image after applying the mean filter.
    """
    # Define the kernel
    kernel = np.ones((kernel_size, kernel_size)) / (kernel_size ** 2)

    # Apply convolution with the kernel using OpenCV's filter2D function
    filtered_image = cv2.filter2D(image, -1, kernel)

    return filtered_image

def gaussian_filter(image, kernel_size=3, sigma=1):
    """
    Apply a Gaussian filter to the image.

    Args:
        image: A numpy array representing the input image.
        kernel_size: The size of the square kernel (default: 3).
        sigma: The standard deviation of the Gaussian distribution (default: 1).

    Returns:
        A numpy array representing the image after applying the Gaussian filter.
    """
    # Generate Gaussian kernel
    kernel = cv2.getGaussianKernel(kernel_size, sigma)
    kernel = np.outer(kernel, kernel.transpose())

    # Apply convolution with the kernel using OpenCV's filter2D function
    filtered_image = cv2.filter2D(image, -1, kernel)

    return filtered_image

def sobel_filter(image):
    """
    Apply the Sobel filter to the image for edge detection.

    Args:
        image: A numpy array representing the input image.

    Returns:
        A numpy array representing the image after applying the Sobel filter.
    """
    # Apply Sobel filter for horizontal gradient
    sobel_x = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)
    
    # Apply Sobel filter for vertical gradient
    sobel_y = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)

    # Combine horizontal and vertical gradients to get the gradient magnitude
    gradient_magnitude = np.sqrt(sobel_x**2 + sobel_y**2)

    # Normalize the gradient magnitude to the range [0, 255]
    gradient_magnitude = cv2.normalize(gradient_magnitude, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)

    return gradient_magnitude

def convert_to_grayscale(image):
    """
    Converts an image to grayscale.

    Args:
        image: A NumPy array representing the image (BGR or RGB format).

    Returns:
        A NumPy array representing the grayscale image.
    """
    # Check if image is already grayscale
    if len(image.shape) == 2:
        return image  # Already grayscale

    # Convert the image to grayscale using OpenCV's BGR2GRAY conversion
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    return gray_image


def laplacian_filter(image):
    """
    Apply the Laplacian filter to the grayscale image for edge detection.

    Args:
        image: A numpy array representing the input image.

    Returns:
        A numpy array representing the image after applying the Laplacian filter.
    """
    # Convert the input image to grayscale
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Apply Laplacian filter using OpenCV's Laplacian function
    laplacian = cv2.Laplacian(gray_image, cv2.CV_64F)

    # Convert the output to uint8 and scale to [0, 255]
    laplacian = cv2.normalize(laplacian, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)

    return laplacian

def min_max_filter(image, kernel_size=3, mode='min'):
    """
    Apply the min-max filter to the image.

    Args:
        image: A numpy array representing the input image.
        kernel_size: The size of the square kernel (default: 3).
        mode: The mode of the filter ('min' or 'max') (default: 'min').

    Returns:
        A numpy array representing the image after applying the min-max filter.
    """
    # Define the kernel
    kernel = np.ones((kernel_size, kernel_size))

    # Apply minimum or maximum filter
    if mode == 'min':
        filtered_image = cv2.erode(image, kernel)
    elif mode == 'max':
        filtered_image = cv2.dilate(image, kernel)
    else:
        raise ValueError("Invalid mode. Mode must be 'min' or 'max'.")

    return filtered_image

def median_filter(image, kernel_size=3):
    """
    Apply the median filter to the image.

    Args:
        image: A numpy array representing the input image.
        kernel_size: The size of the square kernel (default: 3).

    Returns:
        A numpy array representing the image after applying the median filter.
    """
    # Ensure that kernel_size is odd
    if kernel_size % 2 == 0:
        kernel_size += 1

    # Apply median filter using OpenCV's medianBlur function
    filtered_image = cv2.medianBlur(image, kernel_size)

    return filtered_image

# Define preprocessing function choices (must be before using in Dropdown)
preprocessing_functions = [
    ("Grayscale", grayscale),
    ("Blur", blur),
    ("Edge Detection", edge_detection),
    ("Invert Colors", invert_colors),
    ("Threshold", threshold),
    ("Gray Level Transform", gray_level_transform),
    ("Negative Transform", negative_transform),
    ("Log Transform", log_transform),
    ("Power Law Transform", power_law_transform),
    ("Contrast Stretching", contrast_stretching),
    ("intensity slicing", intensity_slicing),
    ("histogram equalization", histogram_equalization),
    ("mean filter", mean_filter),
    ("gaussian filter", gaussian_filter),
    ("sobel filter", sobel_filter),
    ("laplacian filter", laplacian_filter),
    ("min max filter", min_max_filter), 
    ("median filter", median_filter),
]

input_image = gr.components.Image(label="Upload Image")
function_selector = gr.components.Dropdown(choices=[func[0] for func in preprocessing_functions], label="Select Preprocessing Function")

# Define slider for alpha value
alpha_slider = gr.components.Slider(minimum=-100, maximum=100, label="alpha")
alpha_slider.default = 0  # Set default value for alpha

# Define slider for beta value
beta_slider = gr.components.Slider(minimum=0.1, maximum=3.0, label="beta")
beta_slider.default = 1.0  # Set default value for beta

# Define slider for c_log value
c_log_slider = gr.components.Slider(minimum=0.1, maximum=3.0, label="c_log")
c_log_slider.default = 1.0  # Set default value for c_log

# Define slider for gamma value
gamma_slider = gr.components.Slider(minimum=0.1, maximum=3.0, label="gamma")
gamma_slider.default = 1.0  # Set default value for gamma

# Define slider for slicing_threshold value
slicing_threshold_slider = gr.components.Slider(minimum=0, maximum=255, label="slicing threshold")
slicing_threshold_slider.default = 125.0  # Set default value for slicing_threshold

# Define slider for kernel size value
kernel_size_slider = gr.components.Slider(minimum=2, maximum=5, label="kernel size")
kernel_size_slider.default = 3  # Set default value for kernel size

# Define slider for kernel size value
sigma_slider = gr.components.Slider(minimum=2, maximum=5, label="sigma")
sigma_slider.default = 1  # Set default value for kernel size

def apply_preprocessing(image, selected_function, alpha, beta, c_log, gamma, slicing_threshold, kernel_size, sigma):
    # Find the actual function based on the user-friendly name
    selected_function_obj = None
    for func_name, func_obj in preprocessing_functions:
        if func_name == selected_function:
            selected_function_obj = func_obj
            break
    if selected_function_obj is None:
        raise ValueError("Selected function not found.")
    # For gray level transformation, pass beta and gamma values
    if selected_function == "Gray Level Transform":
        processed_image = selected_function_obj(image, alpha=alpha, beta=beta)
    elif selected_function == "Log Transform":
        processed_image = selected_function_obj(image, c=c_log)    
    elif selected_function == "Power Law Transform":
        processed_image = selected_function_obj(image, gamma=gamma)     
    elif selected_function == "intensity slicing":
        processed_image = selected_function_obj(image, threshold=slicing_threshold)
    elif selected_function == "mean filter":
        processed_image = selected_function_obj(image, kernel_size=kernel_size)
    elif selected_function == "gaussian filter":
        processed_image = selected_function_obj(image, kernel_size=kernel_size, sigma=sigma)  
    elif selected_function == "gaussian filter":
        processed_image = selected_function_obj(image, kernel_size=kernel_size, sigma=sigma)
    elif selected_function == "min max filter":
        processed_image = selected_function_obj(image, kernel_size=kernel_size)
    elif selected_function == "median filter":
        processed_image = selected_function_obj(image, kernel_size=kernel_size)                    
    else:
        print(selected_function_obj)
        processed_image = selected_function_obj(image)
    return processed_image

output_image = gr.components.Image(label="Processed Image")

# Create Gradio interface
gr.Interface(
    fn=apply_preprocessing,
    inputs=[input_image, function_selector, alpha_slider, beta_slider, c_log_slider, gamma_slider, slicing_threshold_slider, kernel_size_slider, sigma_slider],
    outputs=output_image,
    title="Elza3ama studio",
    description="Upload an image and select a preprocessing function."
).launch()