New copypasta

app.py

@@ -2,112 +2,98 @@ import gradio as gr
 import numpy as np
 from pylops.signalprocessing import Radon2D
 
-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.
+def compute_radon_fn(image):
+    # Convert image to grayscale if needed.
     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 = Radon2D(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.
+    M, N = image_gray.shape
+    # Define axes centered around zero.
+    taxis = np.linspace(-M/2, M/2, M)   # time axis (rows)
+    haxis = np.linspace(-N/2, N/2, N)   # spatial axis (columns)
+    # Set detector axis (pxaxis) to cover the full image diagonal.
+    L = int(np.ceil(np.sqrt(M**2 + N**2)))
+    pxaxis = np.linspace(-L/2, L/2, L)
+
+    # Create the Radon2D operator with engine 'numba' and centeredh=True.
+    R = Radon2D(taxis, haxis, pxaxis,
+                kind='linear', centeredh=True, interp=True,
+                onthefly=False, engine='numba', dtype='float64', name='R')
+
+    # Compute the forward radon transform.
+    radon_data_flat = R.dot(image_gray.flatten())
+    # Deduce the number of projections from the operator shape.
+    nproj = R.shape[0] // L
+    # Reshape to (nproj, L) so each row corresponds to one projection.
+    radon_data = radon_data_flat.reshape((nproj, L))
+    
+    # Transpose for display: p (detector coordinate) on x-axis, τ on y-axis.
+    radon_display = radon_data.T
+    # Normalize for display.
+    radon_display = (radon_display - radon_display.min()) / (radon_display.max() - radon_display.min() + 1e-8)
+    
+    # Save the state including the radon data and operator for inverse computation.
     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
+         "radon_data": radon_data,     # shape: (nproj, L)
+         "image_shape": image_gray.shape,
+         "R": R,                       # the Radon2D operator
+         "L": L                        # detector length
     }
-    
-    return sinogram_display, state
+    return radon_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.
+    # Ensure 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)
+
+    radon_data = state["radon_data"]
     image_shape = tuple(state["image_shape"])
-    angles = np.array(state["angles"])
+    L = state["L"]
     
-    # The displayed sinogram was transposed (shape (L, num_angles)); we transpose the mask
-    # to align with the stored sinogram (shape (num_angles, L)).
+    # The displayed radon image was transposed, so transpose mask back.
     mask = mask_image.T
-    # Create a binary mask; here we consider pixels with value > 0.5 as “painted.”
+    # Create binary mask: painted pixels (value > 0.5) become 1.
     mask_binary = (mask > 0.5).astype(float)
     
-    # Apply the mask to the sinogram (zeroing out painted pixels).
-    sinogram_masked = sinogram * (1 - mask_binary)
+    # Apply the mask: zero-out masked pixels in the radon data.
+    radon_masked = radon_data * (1 - mask_binary)
     
-    # Reconstruct the image using the adjoint of the radon operator.
-    R = Radon2D(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())
+    # Reconstruct the image using the adjoint (transpose) of the operator.
+    R = state["R"]
+    rec_flat = R.T.dot(radon_masked.flatten())
     rec = rec_flat.reshape(image_shape)
-    
-    # Normalize the reconstructed image to [0,1] for display.
+    # Normalize reconstruction 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")
+    gr.Markdown("## Radon Transform with Interactive Masking (Using PyLops Radon2D)")
     
     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_output = gr.Image(label="Radon Transform Image", interactive=False, type="numpy")
+    # Use the updated ImageEditor component for interactive masking.
     radon_drawing = gr.ImageEditor(label="Paint on Radon (mask out pixels)", type="numpy")
     inverse_output = gr.Image(label="Reconstructed Image", interactive=False, type="numpy")
     
-    # State to store parameters and the computed sinogram.
+    # State to hold radon data and operator.
     state = gr.State()
     
-    # When the user clicks the button, compute the radon transform.
+    # When "Compute Radon" is clicked, compute the radon transform.
     compute_button.click(
         fn=compute_radon_fn,
-        inputs=[image_input, num_angles_slider, angle_min_slider, angle_max_slider],
+        inputs=[image_input],
         outputs=[radon_output, state]
     )
     
-    # When the user paints on the radon image, apply the mask and compute the inverse.
+    # When the user edits (paints) the radon image, apply the mask and compute the inverse.
     radon_drawing.change(
         fn=apply_mask_and_inverse_fn,
         inputs=[state, radon_drawing],
@@ -115,7 +101,7 @@ with gr.Blocks() as demo:
     )
     
     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."
+        "**Instructions:** Upload an image and click 'Compute Radon' to compute the radon transform using PyLops’ Radon2D (with engine 'numba' and centeredh=True). Then use the paintbrush tool to mask parts of the radon image and see the resulting reconstruction."
     )
 
-demo.launch()
+demo.launch()