Can 3o get it first try

app.py

@@ -0,0 +1,121 @@
+import gradio as gr
+import numpy as np
+from pylops.signalprocessing import Radon
+
+def compute_radon_fn(image, num_angles, angle_min, angle_max):
+    """
+    Given an input image and radon parameters, compute the radon transform.
+    The output sinogram is reshaped and transposed so that the horizontal axis corresponds to p values,
+    and the vertical axis corresponds to the tau (angle index).
+    A state dictionary is returned with the original sinogram, image shape, and angles.
+    """
+    # Convert image to grayscale if it has multiple channels.
+    if image.ndim == 3:
+        image_gray = np.mean(image, axis=2)
+    else:
+        image_gray = image
+
+    # Create an array of angles (in degrees).
+    angles = np.linspace(angle_min, angle_max, int(num_angles), endpoint=False)
+    
+    # Create the radon operator for the given image shape and angles.
+    R = Radon(image_gray.shape, angles=angles)
+    # Compute the radon transform (operator acts on the flattened image).
+    sinogram_flat = R.dot(image_gray.flatten())
+    
+    # The radon operator R has shape (num_angles * L, N) where N is the image size.
+    # We deduce L (the length of each projection) from R.shape.
+    L = R.shape[0] // len(angles)
+    # Reshape to (num_angles, L); note that each row corresponds to one angle.
+    sinogram = sinogram_flat.reshape((len(angles), L))
+    
+    # For display, we want p on the x-axis and tau (angle index) on the y-axis.
+    # Transpose the sinogram to get shape (L, num_angles).
+    sinogram_display = sinogram.T
+    # Normalize the display image to [0,1].
+    sinogram_display = (sinogram_display - sinogram_display.min()) / (sinogram_display.max() - sinogram_display.min() + 1e-8)
+    
+    # Pack the parameters and the original sinogram into a state dict.
+    state = {
+         "sinogram": sinogram,                   # shape: (num_angles, L)
+         "image_shape": image_gray.shape,        # original image dimensions
+         "angles": angles.tolist()               # store as a list for JSON-serialization
+    }
+    
+    return sinogram_display, state
+
+def apply_mask_and_inverse_fn(state, mask_image):
+    """
+    Given the state (which includes the original sinogram, image shape, and angles)
+    and a drawing (mask) provided on the radon image, this function applies the mask
+    (setting painted sinogram pixels to zero) and then computes an inverse transform
+    via the adjoint of the Radon operator.
+    """
+    if mask_image is None:
+        return None
+
+    # Ensure the mask is single-channel.
+    if mask_image.ndim == 3:
+        mask_image = mask_image[..., 0]
+    
+    # Retrieve stored sinogram and parameters.
+    sinogram = state["sinogram"]      # shape: (num_angles, L)
+    image_shape = tuple(state["image_shape"])
+    angles = np.array(state["angles"])
+    
+    # The displayed sinogram was transposed (shape (L, num_angles)); we transpose the mask
+    # to align with the stored sinogram (shape (num_angles, L)).
+    mask = mask_image.T
+    # Create a binary mask; here we consider pixels with value > 0.5 as “painted.”
+    mask_binary = (mask > 0.5).astype(float)
+    
+    # Apply the mask to the sinogram (zeroing out painted pixels).
+    sinogram_masked = sinogram * (1 - mask_binary)
+    
+    # Reconstruct the image using the adjoint of the radon operator.
+    R = Radon(image_shape, angles=angles)
+    # The adjoint (transpose) of the radon operator is used as an approximation for the inverse.
+    rec_flat = R.T.dot(sinogram_masked.flatten())
+    rec = rec_flat.reshape(image_shape)
+    
+    # Normalize the reconstructed image to [0,1] for display.
+    rec_norm = (rec - rec.min()) / (rec.max() - rec.min() + 1e-8)
+    return rec_norm
+
+with gr.Blocks() as demo:
+    gr.Markdown("## Radon Transform with Interactive Masking")
+    
+    with gr.Row():
+        image_input = gr.Image(label="Input Image", type="numpy")
+        with gr.Column():
+            num_angles_slider = gr.Slider(10, 360, step=1, value=180, label="Number of Angles")
+            angle_min_slider = gr.Slider(0, 360, step=1, value=0, label="Angle Min (degrees)")
+            angle_max_slider = gr.Slider(0, 360, step=1, value=180, label="Angle Max (degrees)")
+    
+    compute_button = gr.Button("Compute Radon")
+    radon_output = gr.Image(label="Radon Transform", interactive=False, type="numpy")
+    radon_drawing = gr.Image(label="Paint on Radon (mask out pixels)", type="numpy", tool="sketch")
+    inverse_output = gr.Image(label="Reconstructed Image", interactive=False, type="numpy")
+    
+    # State to store parameters and the computed sinogram.
+    state = gr.State()
+    
+    # When the user clicks the button, compute the radon transform.
+    compute_button.click(
+        fn=compute_radon_fn,
+        inputs=[image_input, num_angles_slider, angle_min_slider, angle_max_slider],
+        outputs=[radon_output, state]
+    )
+    
+    # When the user paints on the radon image, apply the mask and compute the inverse.
+    radon_drawing.change(
+        fn=apply_mask_and_inverse_fn,
+        inputs=[state, radon_drawing],
+        outputs=[inverse_output]
+    )
+    
+    gr.Markdown(
+        "**Instructions:** Upload an image and adjust the radon parameters. Click 'Compute Radon' to see the sinogram (displayed with p values on the x-axis and τ on the y-axis). Then use the paintbrush tool to mask out regions of the sinogram and see how the inverse transform (reconstruction) changes."
+    )
+
+demo.launch()