Mastering MRI k-Space Processing in MATLAB: A Step-by-Step Coursework Guide

Introduction to MRI Signal Processing in MATLAB

Magnetic Resonance Imaging (MRI) is a cornerstone of modern medical diagnostics, producing high-resolution images of soft tissues without ionizing radiation. Unlike X-ray or ultrasound, MRI acquires data in the spatial frequency domain—known as k-space. To reconstruct a clinically useful image, you must apply an inverse Fourier transform and subsequent processing steps. This tutorial walks through the key tasks from a typical MPHY0020 coursework, focusing on MATLAB implementation of k-space visualization, image reconstruction, filtering, rotation correction, and segmentation. Whether you're a biomedical engineering student or a researcher, these skills are essential for handling real MRI datasets. Think of k-space as the 'recipe' of spatial frequencies: just as a chef combines ingredients in precise proportions, you combine frequency components to create the final image. In the era of AI-driven medical imaging, understanding these fundamentals remains critical—even deep learning models often rely on Fourier-based preprocessing.

Task 1: Visualizing k-Space with Logarithmic Compression

Raw MRI data is stored as complex numbers in k-space. Each point represents a spatial frequency component. Directly displaying the magnitude often yields a dark image dominated by the central low-frequency peak. To improve interpretability, apply a logarithmic transform: L = |log10(|E|)|, where L is in dB. Use a dynamic range of 20 dB. Also, convert pixel indices to spatial frequency coordinates (mm⁻¹) using the field of view (FOV) and matrix size. For a dataset with Δx = Δy = 0.43 mm, compute FOVx = Nx * Δx and FOVy = Ny * Δy, then kx = (-Nx/2 : Nx/2-1) / FOVx, and similarly for ky.

% Load k-space data
load('kspace_single_slice.mat'); % contains variable kspace
% Compute magnitude and log compression
mag = abs(kspace);
L = log10(mag + eps); % avoid log(0)
% Display with 20 dB range
imagesc(kx, ky, L, [max(L(:))-20, max(L(:))]);
axis xy; colormap(gray); colorbar;
xlabel('kx (mm^{-1})'); ylabel('ky (mm^{-1})');
title('Log-compressed k-space (20 dB dynamic range)');

This visualization reveals the energy distribution across frequencies. In practice, clinicians rarely view raw k-space, but engineers inspect it to assess noise and motion artifacts. For example, a recent trend in AI-based MRI reconstruction uses k-space undersampling patterns—understanding this display helps you design better sampling strategies.

Task 2: Image Reconstruction via Inverse Fourier Transform

To obtain the spatial domain image, apply the 2D inverse fast Fourier transform (IFFT) to the complex k-space data. Use ifftshift before and after to correct quadrant ordering. Scale the resulting image so that its maximum pixel value equals 1. Display the magnitude image.

% Reconstruct image
recon = ifftshift(ifft2(ifftshift(kspace)));
recon_mag = abs(recon);
recon_mag = recon_mag / max(recon_mag(:)); % scale to [0,1]
% Display
imshow(recon_mag);
title('Reconstructed MRI Slice');
colormap(gray); colorbar;

The reconstructed image shows anatomical structures like the brain's gray-white matter boundary. This step is analogous to rendering a 3D scene in a game engine—raw data becomes a visual experience. In modern medical AI apps, this reconstruction is the first step before segmentation or diagnosis.

Task 3: k-Space Filtering for Contrast and Edge Enhancement

Filtering in k-space allows selective preservation or suppression of spatial frequencies. A low-pass filter (e.g., a circular mask) retains central k-space, smoothing the image but blurring edges. A high-pass filter suppresses low frequencies, enhancing edges but reducing overall contrast. Implement a binary mask: for low-pass, set all pixels outside a radius R to zero; for high-pass, set pixels inside R to zero. Apply the mask to k-space before reconstruction.

% Create low-pass mask (radius = 20 pixels)
[Nx, Ny] = size(kspace);
[X, Y] = meshgrid(1:Ny, 1:Nx);
center = [Nx/2+0.5, Ny/2+0.5];
R = 20;
mask = sqrt((X-center(2)).^2 + (Y-center(1)).^2) <= R;
% Apply filter
kspace_filtered = kspace .* mask;
% Reconstruct and display (similar to Task 2)
recon_lp = ifftshift(ifft2(ifftshift(kspace_filtered)));
recon_lp_mag = abs(recon_lp);
recon_lp_mag = recon_lp_mag / max(recon_lp_mag(:));
imshow(recon_lp_mag); title('Low-pass filtered');

Compare with the original: low-pass yields a blurrier image, while high-pass (using ~mask) reveals edges. This is similar to Instagram filters—one smooths skin, the other sharpens details. In MRI-guided radiotherapy, such filtering helps delineate tumors.

Task 4: Rotation Correction in k-Space

Patient motion during acquisition can cause rotation of the imaged anatomy. If you have a reference image (e.g., from a previous scan), you can correct rotation by estimating the angle difference in k-space. The magnitude of k-space rotates by the same angle as the image. Use a technique like phase correlation or simply rotate the k-space data using imrotate with appropriate interpolation. After correction, reconstruct and compare with the reference.

% Assume ref_kspace and mov_kspace are loaded
% Estimate rotation angle (simplified: use manual or automated method)
% For demonstration, rotate by known angle
angle = 5; % degrees
kspace_corrected = imrotate(mov_kspace, -angle, 'bilinear', 'crop');
% Reconstruct and display
recon_corr = ifftshift(ifft2(ifftshift(kspace_corrected)));
recon_corr_mag = abs(recon_corr);
recon_corr_mag = recon_corr_mag / max(recon_corr_mag(:));
imshowpair(recon_ref_mag, recon_corr_mag, 'montage');
title('Reference (left) vs Corrected (right)');

Rotation correction is crucial in longitudinal studies, e.g., tracking tumor growth over months. In self-driving car technology, similar algorithms correct camera orientation—showing how signal processing transcends disciplines.

Task 5: Segmentation of Anatomical Structures and Tumors

Segmentation identifies regions of interest (ROI) like gray matter, white matter, or tumors. Simple methods include thresholding based on pixel intensity, region growing, or k-means clustering. For a brain MRI, you might segment the brain from the skull using a mask derived from the magnitude image. For tumor segmentation, use intensity and texture features.

% Simple thresholding for brain mask
brain_mask = recon_mag > 0.2; % adjust threshold
% Clean up with morphological operations
brain_mask = imfill(brain_mask, 'holes');
brain_mask = bwareaopen(brain_mask, 1000);
% Display overlay
imshow(recon_mag); hold on;
visboundaries(brain_mask, 'Color', 'r');
title('Brain Segmentation');

For tumor segmentation, you might use a more advanced method like Otsu's thresholding or a trained U-Net (if allowed). In the context of AI in healthcare, segmentation is a hot topic—companies like Google Health use similar techniques to detect breast cancer. Your MATLAB implementation builds foundational understanding.

Best Practices for MATLAB Coursework

• Comment your code: Explain each step, especially the mathematical formulas. Use block comments for sections.
• Use meaningful variable names: e.g., kspace_data, recon_image, lowpass_mask.
• Vectorize operations: Avoid loops for pixel-wise operations; use matrix operations.
• Handle memory: Clear large variables when not needed, use single precision if appropriate.
• Error checking: Verify file exists before loading, check dimensions match.

These practices not only earn marks but also make your code reusable—like a well-documented open-source library on GitHub. In the age of reproducible research, clean code is a superpower.

Conclusion

This tutorial covered the core steps of MRI processing in MATLAB: k-space visualization, image reconstruction, filtering, rotation correction, and segmentation. Each task builds on the previous, mirroring a real-world pipeline from raw data to clinical insight. By mastering these techniques, you're not just completing coursework—you're preparing for careers in medical imaging, AI research, or biomedical engineering. As MRI continues to evolve with deep learning and real-time processing, the fundamentals you've learned here will remain invaluable. Practice with your own datasets, experiment with parameters, and soon you'll be able to process MRI data like a pro.