%% ===== D-S Settings =====
groupList          = ["/images/MOT_3D_Camera/in_situ_absorption", "/images/ODT_1_Axis_Camera/in_situ_absorption", ...
                      "/images/ODT_2_Axis_Camera/in_situ_absorption", "/images/Horizontal_Axis_Camera/in_situ_absorption", ...
                      "/images/Vertical_Axis_Camera/in_situ_absorption"];

folderPath         = "//DyLabNAS/Data/TwoDGas/2025/06/23/";

run                = '0300';

folderPath         = strcat(folderPath, run);

cam                = 5; 

angle              = 0;
center             = [1410, 2030];
span               = [200, 200];
fraction           = [0.1, 0.1];

pixel_size         = 5.86e-6;         % in meters
magnification      = 23.94;
removeFringes      = false;

ImagingMode        = 'HighIntensity';
PulseDuration      = 5e-6;            % in s

% Fourier analysis settings

% Radial Spectral Distribution
theta_min          = deg2rad(0);
theta_max          = deg2rad(180);
N_radial_bins      = 500;
Radial_Sigma       = 2;
Radial_WindowSize  = 5; % Choose an odd number for a centered moving average

% Angular Spectral Distribution
r_min              = 10;
r_max              = 20;
N_angular_bins     = 180;
Angular_Threshold  = 75;
Angular_Sigma      = 2;
Angular_WindowSize = 5;

zoom_size          = 50;             % Zoomed-in region around center

% Plotting and saving
scan_parameter              = 'ps_rot_mag_fin_pol_angle';
% scan_parameter              = 'rot_mag_field';

savefileName                = 'DropletsToStripes';
font                        = 'Bahnschrift';

if strcmp(savefileName, 'DropletsToStripes')
    scan_groups           = 0:5:45;
    titleString           = 'Droplets to Stripes';
elseif strcmp(savefileName, 'StripesToDroplets')
    scan_groups           = 45:-5:0;
    titleString           = 'Stripes to Droplets';
end

% Flags
skipNormalization           = true;
skipUnshuffling             = true;
skipPreprocessing           = true;
skipMasking                 = true;
skipIntensityThresholding   = true;
skipBinarization            = true;
skipMovieRender             = true;
skipSaveFigures             = true;
skipSaveOD                  = true;

%% ===== S-D Settings =====
groupList          = ["/images/MOT_3D_Camera/in_situ_absorption", "/images/ODT_1_Axis_Camera/in_situ_absorption", ...
                      "/images/ODT_2_Axis_Camera/in_situ_absorption", "/images/Horizontal_Axis_Camera/in_situ_absorption", ...
                      "/images/Vertical_Axis_Camera/in_situ_absorption"];

folderPath         = "//DyLabNAS/Data/TwoDGas/2025/07/23/";

run                = '0055';

folderPath         = strcat(folderPath, run);

cam                = 5; 

angle              = 0;
center             = [1410, 2030];
span               = [200, 200];
fraction           = [0.1, 0.1];

pixel_size         = 5.86e-6;         % in meters
magnification      = 23.94;
removeFringes      = false;

ImagingMode        = 'HighIntensity';
PulseDuration      = 5e-6;            % in s

% Fourier analysis settings

% Radial Spectral Distribution
theta_min          = deg2rad(0);
theta_max          = deg2rad(180);
N_radial_bins      = 500;
Radial_Sigma       = 2;
Radial_WindowSize  = 5; % Choose an odd number for a centered moving average

% Angular Spectral Distribution
r_min              = 10;
r_max              = 20;
N_angular_bins     = 180;
Angular_Threshold  = 75;
Angular_Sigma      = 2;
Angular_WindowSize = 5;

zoom_size          = 50;             % Zoomed-in region around center

% Plotting and saving
scan_parameter              = 'ps_rot_mag_fin_pol_angle';
% scan_parameter              = 'rot_mag_field';

savefileName                = 'StripesToDroplets';
font                        = 'Bahnschrift';

if strcmp(savefileName, 'DropletsToStripes')
    scan_groups           = 0:1:40
    titleString           = 'Droplets to Stripes';
elseif strcmp(savefileName, 'StripesToDroplets')
    scan_groups           = 40:-1:0;
    titleString           = 'Stripes to Droplets';
end

% Flags
skipNormalization           = true;
skipUnshuffling             = false;
skipPreprocessing           = true;
skipMasking                 = true;
skipIntensityThresholding   = true;
skipBinarization            = true;
skipMovieRender             = true;
skipSaveFigures             = true;
skipSaveOD                  = true;

%% ===== Load and compute OD image, rotate and extract ROI for analysis =====
% Get a list of all files in the folder with the desired file name pattern.

filePattern                    = fullfile(folderPath, '*.h5');
files                          = dir(filePattern);
refimages                      = zeros(span(1) + 1, span(2) + 1, length(files));
absimages                      = zeros(span(1) + 1, span(2) + 1, length(files));

for k = 1 : length(files)
    baseFileName = files(k).name;
    fullFileName = fullfile(files(k).folder, baseFileName);
    
    fprintf(1, 'Now reading %s\n', fullFileName);
    
    atm_img  = double(imrotate(h5read(fullFileName, append(groupList(cam), "/atoms")), angle));
    bkg_img  = double(imrotate(h5read(fullFileName, append(groupList(cam), "/background")), angle));
    dark_img = double(imrotate(h5read(fullFileName, append(groupList(cam), "/dark")), angle));
    
    if (isempty(atm_img)  && isa(atm_img, 'double')) || ...
       (isempty(bkg_img)  && isa(bkg_img, 'double')) || ...
       (isempty(dark_img) && isa(dark_img, 'double'))
        
        refimages(:,:,k) = nan(size(refimages(:,:,k)));  % fill with NaNs
        absimages(:,:,k) = nan(size(absimages(:,:,k)));
    else
        refimages(:,:,k)  = subtractBackgroundOffset(cropODImage(bkg_img, center, span), fraction)';
        absimages(:,:,k)  = subtractBackgroundOffset(cropODImage(calculateODImage(atm_img, bkg_img, dark_img, ImagingMode, PulseDuration), center, span), fraction)';
    end
end

% ===== Fringe removal =====

if removeFringes
    optrefimages               = removefringesInImage(absimages, refimages);
    absimages_fringe_removed   = absimages(:, :, :) - optrefimages(:, :, :);
    
    nimgs                      = size(absimages_fringe_removed,3);
    od_imgs                    = cell(1, nimgs);
    for i = 1:nimgs
        od_imgs{i}             = absimages_fringe_removed(:, :, i);
    end
else
    nimgs                      = size(absimages(:, :, :),3);
    od_imgs                    = cell(1, nimgs);
    for i = 1:nimgs
        od_imgs{i}             = absimages(:, :, i);
    end
end

%% ===== Get rotation angles =====
scan_parameter_values   = zeros(1, length(files));

% Get information about the '/globals' group
for k = 1 : length(files)
    baseFileName = files(k).name;
    fullFileName = fullfile(files(k).folder, baseFileName);
    info = h5info(fullFileName, '/globals');
    for i = 1:length(info.Attributes)
        if strcmp(info.Attributes(i).Name, scan_parameter)
            if strcmp(scan_parameter, 'ps_rot_mag_fin_pol_angle')
                scan_parameter_values(k) = 180 - info.Attributes(i).Value;
            else
                scan_parameter_values(k) = info.Attributes(i).Value;
            end
        end
    end
end

% ===== Unshuffle if necessary to do so  =====

if ~skipUnshuffling
    n_values = length(scan_groups);
    n_total  = length(scan_parameter_values);
    
    % Infer number of repetitions
    n_reps   = n_total / n_values;
    
    % Preallocate ordered arrays
    ordered_scan_values = zeros(1, n_total);
    ordered_od_imgs = cell(1, n_total);
    
    counter = 1;
    
    for rep = 1:n_reps
        for val = scan_groups
            % Find the next unused match for this val
            idx = find(scan_parameter_values == val, 1, 'first');
    
            % Assign and remove from list to avoid duplicates
            ordered_scan_values(counter) = scan_parameter_values(idx);
            ordered_od_imgs{counter} = od_imgs{idx};
    
            % Mark as used by removing
            scan_parameter_values(idx) = NaN;  % NaN is safe since original values are 0:5:45
            od_imgs{idx} = [];  % empty cell so it won't be matched again
    
            counter = counter + 1;
        end
    end
    
    % Now assign back
    scan_parameter_values = ordered_scan_values;
    od_imgs = ordered_od_imgs;
end

%% ===== Run Fourier analysis over images  =====

fft_imgs                  = cell(1, nimgs);
radial_spectral_contrast  = zeros(1, nimgs);
angular_spectral_weight   = zeros(1, nimgs);
N_shots                   = length(od_imgs);

if ~skipMovieRender
    % Create VideoWriter object for movie
    videoFile           = VideoWriter([savefileName '.mp4'], 'MPEG-4');
    videoFile.Quality   = 100; % Set quality to maximum (0–100)
    videoFile.FrameRate = 2;  % Set the frame rate (frames per second)
    open(videoFile);  % Open the video file to write
end

if ~skipSaveFigures
    % Define folder for saving images
    saveFolder = [savefileName '_SavedFigures'];
    if ~exist(saveFolder, 'dir')
        mkdir(saveFolder);
    end
end

ps_list      = cell(1, N_shots);  % 2D power spectrum
s_k_list     = cell(1, N_shots);  % Radial spectrum
s_theta_list = cell(1, N_shots);  % Angular spectrum

for k = 1:N_shots
    IMG                   = od_imgs{k};
    if ~(max(IMG(:)) > 1)
        IMGFFT            = NaN(size(IMG));
    else
        [IMGFFT, IMGPR]   = computeFourierTransform(IMG, skipPreprocessing, skipMasking, skipIntensityThresholding, skipBinarization);
    end
        
    % Size of original image (in pixels)
    [Ny, Nx]              = size(IMG);
    
    % Real-space pixel size in micrometers after magnification
    dx                    = pixel_size / magnification;
    dy                    = dx;  % assuming square pixels
    
    % Real-space axes
    x                     = ((1:Nx) - ceil(Nx/2)) * dx * 1E6;
    y                     = ((1:Ny) - ceil(Ny/2)) * dy * 1E6;
    
    % Reciprocal space increments (frequency domain, μm⁻¹)
    dvx                   = 1 / (Nx * dx);
    dvy                   = 1 / (Ny * dy);
    
    % Frequency axes
    vx                    = (-floor(Nx/2):ceil(Nx/2)-1) * dvx;
    vy                    = (-floor(Ny/2):ceil(Ny/2)-1) * dvy;
    
    % Wavenumber axes
    kx_full               = 2 * pi * vx * 1E-6;  % μm⁻¹
    ky_full               = 2 * pi * vy * 1E-6;
    
    % Crop FFT image around center
    mid_x                 = floor(Nx/2);
    mid_y                 = floor(Ny/2);
    fft_imgs{k}           = IMGFFT(mid_y-zoom_size:mid_y+zoom_size, mid_x-zoom_size:mid_x+zoom_size);
    
    % Crop wavenumber axes to match fft_imgs{k}
    kx                    = kx_full(mid_x - zoom_size : mid_x + zoom_size);
    ky                    = ky_full(mid_y - zoom_size : mid_y + zoom_size);
    
    [theta_vals, S_theta] = computeAngularSpectralDistribution(fft_imgs{k}, r_min, r_max, N_angular_bins, Angular_Threshold, Angular_Sigma, []);
    [k_rho_vals, S_k]     = computeRadialSpectralDistribution(fft_imgs{k}, kx, ky, theta_min, theta_max, N_radial_bins);
    S_k_smoothed          = movmean(S_k, Radial_WindowSize);  % % Compute moving average (use convolution) or use conv for more control
    
    radial_spectral_contrast(k)  = computeRadialSpectralContrast(fft_imgs{k}, r_min, r_max, Angular_Threshold);
    S_theta_norm                 = S_theta / max(S_theta); % Normalize to 1
    angular_spectral_weight(k)   = trapz(theta_vals, S_theta_norm);
    
    ps_list{k}      = abs(fft_imgs{k}).^2;  % store the power spectrum
    s_k_list{k}     = S_k_smoothed;         % store smoothed radial spectrum
    s_theta_list{k} = S_theta;              % store angular spectrum
    
    figure(1);
    clf
    set(gcf,'Position',[500 100 1000 800])
    t = tiledlayout(2, 2, 'TileSpacing', 'compact', 'Padding', 'compact');
        
    % ======= OD IMAGE (real space) =======
    ax1 = nexttile;
    imagesc(x, y, IMG)

    hold on;

    % Convert pixel grid to µm (already done: x and y axes)
    % Draw ↘ diagonal (top-left to bottom-right)
    drawODOverlays(x(1), y(1), x(end), y(end));
    
    % Draw ↙ diagonal (top-right to bottom-left)
    drawODOverlays(x(end), y(1), x(1), y(end));
    
    hold off;

    axis equal tight;
    set(gca, 'FontSize', 14, 'YDir', 'normal')
    colormap(ax1,  Colormaps.inferno());
    hcb = colorbar;
    ylabel(hcb, 'Optical Density', 'Rotation', -90, 'FontSize', 14, 'FontName', font);
    
    xlabel('x (\mum)', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    ylabel('y (\mum)', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    title('OD Image', 'FontSize', 16, 'FontWeight', 'bold', 'Interpreter', 'tex', 'FontName', font);
    
    if strcmp(scan_parameter, 'ps_rot_mag_fin_pol_angle')
        text(0.975, 0.975, [num2str(scan_parameter_values(k), '%.1f^\\circ')], ...
            'Color', 'white', 'FontWeight', 'bold', 'FontSize', 14, ...
            'Interpreter', 'tex', 'Units', 'normalized', ...
            'HorizontalAlignment', 'right', 'VerticalAlignment', 'top');
    else
        text(0.975, 0.975, [num2str(scan_parameter_values(k), '%.2f'), ' G'], ...
            'Color', 'white', 'FontWeight', 'bold', 'FontSize', 14, ...
            'Interpreter', 'tex', 'Units', 'normalized', ...
            'HorizontalAlignment', 'right', 'VerticalAlignment', 'top');
    end
    
    % ======= FFT POWER SPECTRUM (reciprocal space) =======
    ax2 = nexttile;
    imagesc(kx, ky, log(1 + ps_list{k}));
    axis image;
    set(gca, 'FontSize', 14, 'YDir', 'normal')
    xlabel('k_x [\mum^{-1}]', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    ylabel('k_y [\mum^{-1}]', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    title('Power Spectrum - S(k_x,k_y)', 'Interpreter', 'tex', ...
          'FontSize', 16, 'FontWeight', 'bold', 'FontName', font);
    colorbar;
    colormap(ax2, Colormaps.coolwarm());
    
    drawPSOverlays(kx, ky, r_min, r_max)
    
    % ======= RADIAL DISTRIBUTION (S(k)) =======
    nexttile;
    plot(k_rho_vals, S_k_smoothed, 'LineWidth', 2);
    set(gca, 'FontSize', 14, 'YScale', 'log', 'XLim', [min(k_rho_vals), max(k_rho_vals)]);
    xlabel('k_\rho [\mum^{-1}]', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    ylabel('Magnitude (a.u.)', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    title('Radial Spectral Distribution - S(k_\rho)', 'Interpreter', 'tex', ...
        'FontSize', 16, 'FontWeight', 'bold', 'FontName', font);
    grid on;
    
    % ======= ANGULAR DISTRIBUTION (S(θ)) =======
    nexttile;
    if ~skipNormalization
        plot(theta_vals/pi, S_theta_norm, 'LineWidth', 2);
        set(gca, 'FontSize', 14, 'YLim', [0, 1]);
    else
        plot(theta_vals/pi, S_theta, 'LineWidth', 2);
        set(gca, 'FontSize', 14, 'YScale', 'log', 'YLim', [1E4, 1E7]);
    end
    xlabel('\theta/\pi [rad]', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    ylabel('Magnitude (a.u.)', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    title('Angular Spectral Distribution - S(\theta)', 'Interpreter', 'tex', ...
        'FontSize', 16, 'FontWeight', 'bold', 'FontName', font);
    grid on;            % Enable major grid
    ax = gca;
    ax.MinorGridLineStyle = ':';  % Optional: make minor grid dotted
    ax.MinorGridColor = [0.7 0.7 0.7]; % Optional: light gray minor grid color
    ax.MinorGridAlpha = 0.5;      % Optional: transparency for minor grid
    
    ax.XMinorGrid = 'on';         % Enable minor grid for x-axis
    ax.YMinorGrid = 'on';         % Enable minor grid for y-axis (if desired)
    
    drawnow;
    
    if ~skipMovieRender
        % Capture the current frame and write it to the video
        frame = getframe(gcf);  % Capture the current figure as a frame
        writeVideo(videoFile, frame);  % Write the frame to the video
    end
    if ~skipSaveFigures
        % Construct a filename for each image
        fileNamePNG = fullfile(saveFolder, sprintf('fft_analysis_img_%03d.png', k));
        
        % Save current figure as PNG with high resolution
        print(gcf, fileNamePNG, '-dpng', '-r100');  % 300 dpi for high quality
    end
    if ~skipSaveOD
        odDataStruct                      = struct();
        odDataStruct.IMG                  = IMG;
        odDataStruct.x                    = x;
        odDataStruct.y                    = y;
        odDataStruct.scan_parameter_value = scan_parameter_values(k);
        save(fullfile(saveFolder, sprintf('od_image_%03d.mat', k)), '-struct', 'odDataStruct');
    end
    if skipMovieRender & skipSaveFigures
        pause(0.5);
    end
end

if ~skipMovieRender
    % Close the video file
    close(videoFile);
end

%% Track across the transition

% Assuming scan_parameter_values and spectral_weight are column vectors (or row vectors of same length)
[unique_scan_parameter_values, ~, idx] = unique(scan_parameter_values);

% Preallocate arrays
mean_sc = zeros(size(unique_scan_parameter_values));
stderr_sc = zeros(size(unique_scan_parameter_values));

% Loop through each unique theta and compute mean and standard error
for i = 1:length(unique_scan_parameter_values)
    group_vals = radial_spectral_contrast(idx == i);
    mean_sc(i) = mean(group_vals);
    stderr_sc(i) = std(group_vals) / sqrt(length(group_vals)); % standard error = std / sqrt(N)
end

figure(2);
set(gcf,'Position',[100 100 950 750])
errorbar(unique_scan_parameter_values, mean_sc, stderr_sc, 'o--', ...
    'LineWidth', 1.5, 'MarkerSize', 6, 'CapSize', 5);
set(gca, 'FontSize', 14);   % For tick labels only
hXLabel = xlabel('\alpha (degrees)', 'Interpreter', 'tex');
hYLabel = ylabel('Radial Spectral Contrast', 'Interpreter', 'tex');
hTitle  = title(titleString, 'Interpreter', 'tex');
% set([hXLabel, hYLabel], 'FontName', font)
set([hXLabel, hYLabel], 'FontSize', 14)
set(hTitle, 'FontName', font, 'FontSize', 16, 'FontWeight', 'bold');  % Set font and size for title
grid on


% Preallocate arrays
mean_sw = zeros(size(unique_scan_parameter_values));
stderr_sw = zeros(size(unique_scan_parameter_values));

% Loop through each unique theta and compute mean and standard error
for i = 1:length(unique_scan_parameter_values)
    group_vals = angular_spectral_weight(idx == i);
    mean_sw(i) = mean(group_vals);
    stderr_sw(i) = std(group_vals) / sqrt(length(group_vals)); % standard error = std / sqrt(N)
end

figure(3);
set(gcf,'Position',[100 100 950 750])
errorbar(unique_scan_parameter_values, mean_sw, stderr_sw, 'o--', ...
    'LineWidth', 1.5, 'MarkerSize', 6, 'CapSize', 5);
set(gca, 'FontSize', 14);   % For tick labels only
hXLabel = xlabel('\alpha (degrees)', 'Interpreter', 'tex');
hYLabel = ylabel('Angular Spectral Weight', 'Interpreter', 'tex');
hTitle  = title(titleString, 'Interpreter', 'tex');
% set([hXLabel, hYLabel], 'FontName', font)
set([hXLabel, hYLabel], 'FontSize', 14)
set(hTitle, 'FontName', font, 'FontSize', 16, 'FontWeight', 'bold');  % Set font and size for title
grid on;

%% Plot Averages

% Group by scan parameter values
[unique_scan_parameter_values, ~, idx] = unique(scan_parameter_values);
N_params = numel(unique_scan_parameter_values);

if ~skipSaveFigures
    % Define folder for saving images
    saveFolder = [savefileName '_SavedFigures'];
    if ~exist(saveFolder, 'dir')
        mkdir(saveFolder);
    end
end

% Loop over each unique parameter value
for p = 1:N_params
    current_param = unique_scan_parameter_values(p);
    indices = find(idx == p);  % Indices of shots for this parameter
    N_shots = numel(indices);

    % Initialize accumulators
    avg_ps      = 0;
    avg_S_k     = 0;
    avg_S_theta = 0;

    % Accumulate values
    for j = 1:N_shots
        avg_ps      = avg_ps      + ps_list{indices(j)};
        avg_S_k     = avg_S_k     + s_k_list{indices(j)};
        avg_S_theta = avg_S_theta + s_theta_list{indices(j)};
    end

    % Average over repetitions
    avg_ps      = avg_ps      / N_shots;
    avg_S_k     = avg_S_k     / N_shots;
    avg_S_theta = avg_S_theta / N_shots;

    % ==== Plot ====
    figure(3);
    set(gcf,'Position',[400 200 1200 400])
    tavg = tiledlayout(1, 3, 'TileSpacing', 'compact', 'Padding', 'compact');

    % 1. Power Spectrum
    nexttile;
    imagesc(kx, ky, log(1 + avg_ps));
    axis image;
    set(gca, 'FontSize', 14, 'YDir', 'normal')
    xlabel('k_x [\mum^{-1}]', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    ylabel('k_y [\mum^{-1}]', 'Interpreter', 'tex', 'FontSize', 14, 'FontName', font);
    title('Average Power Spectrum', 'FontSize', 16, 'FontWeight', 'bold');
    colorbar;
    colormap(Colormaps.coolwarm());

    if strcmp(scan_parameter, 'ps_rot_mag_fin_pol_angle')
        text(0.975, 0.975, [num2str(current_param, '%.1f^\\circ')], ...
            'Color', 'white', 'FontWeight', 'bold', 'FontSize', 14, ...
            'Interpreter', 'tex', 'Units', 'normalized', ...
            'HorizontalAlignment', 'right', 'VerticalAlignment', 'top');
    else
        text(0.975, 0.975, [num2str(current_param, '%.2f'), ' G'], ...
            'Color', 'white', 'FontWeight', 'bold', 'FontSize', 14, ...
            'Interpreter', 'tex', 'Units', 'normalized', ...
            'HorizontalAlignment', 'right', 'VerticalAlignment', 'top');
    end

    % 2. Radial Spectrum
    nexttile;
    plot(k_rho_vals, avg_S_k, 'LineWidth', 2);
    xlabel('k_\rho [\mum^{-1}]', 'Interpreter', 'tex', 'FontSize', 14);
    ylabel('Magnitude (a.u.)', 'Interpreter', 'tex', 'FontSize', 14);
    title('Average S(k_\rho)', 'FontSize', 16, 'FontWeight', 'bold');
    set(gca, 'FontSize', 14, 'YScale', 'log', ...
             'XLim', [min(k_rho_vals), max(k_rho_vals)]);
    grid on;

    % 3. Angular Spectrum
    nexttile;
    plot(theta_vals/pi, avg_S_theta, 'LineWidth', 2);
    xlabel('\theta/\pi [rad]', 'Interpreter', 'tex', 'FontSize', 14);
    ylabel('Magnitude (a.u.)', 'Interpreter', 'tex', 'FontSize', 14);
    title('Average S(\theta)', 'FontSize', 16, 'FontWeight', 'bold');
    set(gca, 'FontSize', 14, 'YScale', 'log', ...
             'YLim', [1E4, 1E7]);
    grid on;
    ax = gca;
    ax.XMinorGrid = 'on';
    ax.YMinorGrid = 'on';
    
    drawnow;

    % ==== Save Figure ====
    if ~skipSaveFigures
        % Create a filename for each averaged plot
        fileNamePNG = fullfile(saveFolder, sprintf('fft_avg_analysis_param_%03d.png', p));
        
        % Save current figure as PNG with high resolution
        print(gcf, fileNamePNG, '-dpng', '-r300');  % 300 dpi for high quality
    else
        pause(0.5)
    end   
end

%% ========= Replot OD images ==========

% Settings
filePattern  = fullfile(saveFolder, 'od_image_*.mat');
files        = dir(filePattern);
colormapName = 'inferno';
showText     = true;
showOverlay  = true;
font         = 'Bahnschrift';

% Load and organize all OD images by parameter and repetition
nFiles = length(files);
if nFiles == 0
    error('No .mat OD image files found in folder: %s', saveFolder);
end

% Load all data and extract parameter values
scan_values = zeros(1, nFiles);
allData     = cell(1, nFiles);

for k = 1:nFiles
    S = load(fullfile(files(k).folder, files(k).name));
    scan_values(k) = S.scan_parameter_value;
    allData{k}     = S;
end

% Get unique parameter values
unique_params = unique(scan_values);
nParams       = numel(unique_params);

% Group images: paramData{i} = [rep1, rep2, ...]

if strcmp(savefileName, 'StripesToDroplets')
    unique_params = fliplr(unique_params);
end

paramData = cell(1, nParams);
for i = 1:nParams
    idxs = find(scan_values == unique_params(i));
    paramData{i} = allData(idxs);
end

% Get number of repetitions (assumes all same)
nReps = max(cellfun(@numel, paramData));

% Initialize figure with one row, nParams columns
figure(100); clf;
% Set number of columns (e.g., 4 or auto-compute from nParams)
nCols = min(4, nParams);
nRows = ceil(nParams / nCols);

% Create tiled layout with multiple rows
t = tiledlayout(nRows, nCols, 'TileSpacing', 'compact', 'Padding', 'compact');

% Adjust figure size accordingly
set(gcf, 'Position', [100 100 300*nCols 300*nRows]);

% Pre-create image handles
axesArray = gobjects(1, nParams);
imgArray  = gobjects(1, nParams);
textArray = gobjects(1, nParams);

for i = 1:nParams
    S = paramData{i}{1};  % First repetition to initialize
    
    ax = nexttile(i);
    axesArray(i) = ax;
    
    imgArray(i) = imagesc(S.x, S.y, S.IMG);
    axis equal tight;
    set(ax, 'YDir', 'normal');
    colormap(ax, Colormaps.(colormapName)());
    colorbar;
    
    xlabel('x [\mum]', 'Interpreter', 'tex', 'FontSize', 12, 'FontName', font);
    ylabel('y [\mum]', 'Interpreter', 'tex', 'FontSize', 12, 'FontName', font);

    if showOverlay
        hold on;
        drawODOverlays(S.x(1), S.y(1), S.x(end), S.y(end));
        drawODOverlays(S.x(end), S.y(1), S.x(1), S.y(end));
        hold off;
    end

    % Add initial label
    if showText
        if strcmp(scan_parameter, 'ps_rot_mag_fin_pol_angle')
            labelStr = sprintf('%.1f^\\circ', S.scan_parameter_value);
        else
            labelStr = sprintf('%.2f G', S.scan_parameter_value);
        end
        textArray(i) = text(ax, 0.975, 0.975, labelStr, ...
            'Color', 'white', 'FontWeight', 'bold', ...
            'FontSize', 12, 'Interpreter', 'tex', ...
            'Units', 'normalized', ...
            'HorizontalAlignment', 'right', ...
            'VerticalAlignment', 'top');
    end
end

% 🔁 Loop over repetitions
for rep = 1:nReps
    for i = 1:nParams
        repsForParam = paramData{i};
        if rep <= numel(repsForParam)
            S = repsForParam{rep};
            imgArray(i).CData = S.IMG;

            % Update text if needed (optional)
            if showText
                if strcmp(scan_parameter, 'ps_rot_mag_fin_pol_angle')
                    labelStr = sprintf('%.1f^\\circ', S.scan_parameter_value);
                else
                    labelStr = sprintf('%.2f G', S.scan_parameter_value);
                end
                textArray(i).String = labelStr;
            end
        end
    end
    drawnow;  % Update figure

    % Optional: pause or save frame
    pause(0.2);
end

%% ========= Replot OD images in chunks by parameter ==========

% Settings
filePattern    = fullfile(saveFolder, 'od_image_*.mat');
files          = dir(filePattern);
colormapName   = 'inferno';
showText       = true;
showOverlay    = true;
font           = 'Bahnschrift';
paramStep      = 2;   % Show every paramStep-th parameter
pauseTime      = 0.2; % Seconds between repetitions

% Load and organize all OD images
nFiles = numel(files);
scan_values = zeros(1, nFiles);
allData     = cell(1, nFiles);

for k = 1:nFiles
    S = load(fullfile(files(k).folder, files(k).name));
    scan_values(k) = S.scan_parameter_value;
    allData{k}     = S;
end

% Sort and group by unique parameter values
[unique_params, ~, ic] = unique(scan_values);
nParams = numel(unique_params);

paramGroups = cell(1, nParams);
for i = 1:nParams
    paramGroups{i} = allData(ic == i);
end

if strcmp(savefileName, 'StripesToDroplets')
    unique_params = fliplr(unique_params);
    paramGroups   = fliplr(paramGroups);
end

% Select a subset of parameters
selectedIdx     = 1:paramStep:nParams;
nDisplayParams  = numel(selectedIdx);
selectedGroups  = paramGroups(selectedIdx);

% Get max number of repetitions
nReps = max(cellfun(@numel, selectedGroups));

% Initialize figure
figure(101); clf;
tiledlayout(1, nDisplayParams, 'TileSpacing', 'compact', 'Padding', 'compact');
set(gcf, 'Position', [100 100 300*nDisplayParams 300]);

imgArray  = gobjects(1, nDisplayParams);
textArray = gobjects(1, nDisplayParams);

% Initial plot (repetition 1)
for j = 1:nDisplayParams
    ax = nexttile;
    group = selectedGroups{j};
    S = group{1};

    imgArray(j) = imagesc(S.x, S.y, S.IMG);
    axis equal tight;
    set(ax, 'YDir', 'normal');
    colormap(ax, Colormaps.(colormapName)());
    colorbar;

    xlabel('x [\mum]', 'Interpreter', 'tex', 'FontSize', 12, 'FontName', font);
    ylabel('y [\mum]', 'Interpreter', 'tex', 'FontSize', 12, 'FontName', font);

    if showOverlay
        hold on;
        drawODOverlays(S.x(1), S.y(1), S.x(end), S.y(end));
        drawODOverlays(S.x(end), S.y(1), S.x(1), S.y(end));
        hold off;
    end

    if showText
        if strcmp(scan_parameter, 'ps_rot_mag_fin_pol_angle')
            labelStr = sprintf('%.1f^\\circ', S.scan_parameter_value);
        else
            labelStr = sprintf('%.2f G', S.scan_parameter_value);
        end
        textArray(j) = text(0.975, 0.975, labelStr, ...
            'Color', 'white', 'FontWeight', 'bold', ...
            'FontSize', 12, 'Interpreter', 'tex', ...
            'Units', 'normalized', ...
            'HorizontalAlignment', 'right', ...
            'VerticalAlignment', 'top');
    end
end

% Loop through repetitions
for rep = 1:nReps
    for j = 1:nDisplayParams
        group = selectedGroups{j};
        if rep <= numel(group)
            S = group{rep};
            imgArray(j).CData = S.IMG;

            if showText
                if strcmp(scan_parameter, 'ps_rot_mag_fin_pol_angle')
                    textArray(j).String = sprintf('%.1f^\\circ', S.scan_parameter_value);
                else
                    textArray(j).String = sprintf('%.2f G', S.scan_parameter_value);
                end
            end
        end
    end
    drawnow;
    pause(pauseTime);
end


%% Helper Functions
function [IMGFFT, IMGPR] = computeFourierTransform(I, skipPreprocessing, skipMasking, skipIntensityThresholding, skipBinarization)
    % computeFourierSpectrum - Computes the 2D Fourier power spectrum 
    % of binarized and enhanced lattice image features, with optional central mask.
    %
    % Inputs:
    %   I           - Grayscale or RGB image matrix
    %
    % Output:
    %   F_mag       - 2D Fourier power spectrum (shifted)
    
    if ~skipPreprocessing
        % Preprocessing: Denoise
        filtered             = imgaussfilt(I, 10);
        IMGPR                = I - filtered; % adjust sigma as needed
    else
        IMGPR                = I;
    end
    
    if ~skipMasking
        [rows, cols]     = size(IMGPR);
        [X, Y]           = meshgrid(1:cols, 1:rows);
        % Elliptical mask parameters
        cx               = cols / 2;
        cy               = rows / 2;
        
        % Shifted coordinates
        x                = X - cx;
        y                = Y - cy;
        
        % Ellipse semi-axes
        rx               = 0.4 * cols;
        ry               = 0.2 * rows;
        
        % Rotation angle in degrees -> radians
        theta_deg        = 30;        % Adjust as needed
        theta            = deg2rad(theta_deg);
        
        % Rotated ellipse equation
        cos_t            = cos(theta);
        sin_t            = sin(theta);
        
        x_rot            = (x * cos_t + y * sin_t);
        y_rot            = (-x * sin_t + y * cos_t);
        
        ellipseMask      = (x_rot.^2) / rx^2 + (y_rot.^2) / ry^2 <= 1;
        
        % Apply cutout mask
        IMGPR            = IMGPR .* ellipseMask;
    end

    if ~skipIntensityThresholding
        % Apply global intensity threshold mask
        intensity_thresh = 0.20; 
        intensity_mask   = IMGPR > intensity_thresh;
        IMGPR            = IMGPR .* intensity_mask;
    end

    if ~skipBinarization
        % Adaptive binarization and cleanup
        IMGPR            = imbinarize(IMGPR, 'adaptive', 'Sensitivity', 0.0);
        IMGPR            = imdilate(IMGPR, strel('disk', 2));
        IMGPR            = imerode(IMGPR, strel('disk', 1));
        IMGPR            = imfill(IMGPR, 'holes');
        F                = fft2(double(IMGPR)); % Compute 2D Fourier Transform
        IMGFFT           = abs(fftshift(F))';  % Shift zero frequency to center
    else
        F                = fft2(double(IMGPR)); % Compute 2D Fourier Transform
        IMGFFT           = abs(fftshift(F))';  % Shift zero frequency to center
    end
end

function [k_rho_vals, S_radial] = computeRadialSpectralDistribution(IMGFFT, kx, ky, thetamin, thetamax, num_bins)
    % IMGFFT    : 2D FFT image (fftshifted and cropped)
    % kx, ky    : 1D physical wavenumber axes [μm⁻¹] matching FFT size
    % thetamin  : Minimum angle (in radians)
    % thetamax  : Maximum angle (in radians)
    % num_bins  : Number of radial bins

    [KX, KY] = meshgrid(kx, ky);
    K_rho = sqrt(KX.^2 + KY.^2);
    Theta = atan2(KY, KX);

    if thetamin < thetamax
        angle_mask = (Theta >= thetamin) & (Theta <= thetamax);
    else
        angle_mask = (Theta >= thetamin) | (Theta <= thetamax);
    end

    power_spectrum = abs(IMGFFT).^2;

    r_min = min(K_rho(angle_mask));
    r_max = max(K_rho(angle_mask));
    r_edges = linspace(r_min, r_max, num_bins + 1);
    k_rho_vals = 0.5 * (r_edges(1:end-1) + r_edges(2:end));
    S_radial = zeros(1, num_bins);

    for i = 1:num_bins
        r_low = r_edges(i);
        r_high = r_edges(i + 1);
        radial_mask = (K_rho >= r_low) & (K_rho < r_high);
        full_mask = radial_mask & angle_mask;
        S_radial(i) = sum(power_spectrum(full_mask));
    end
end

function [theta_vals, S_theta] = computeAngularSpectralDistribution(IMGFFT, r_min, r_max, num_bins, threshold, sigma, windowSize)
    % Apply threshold to isolate strong peaks
    IMGFFT(IMGFFT < threshold) = 0;

    % Prepare polar coordinates
    [ny, nx]  = size(IMGFFT);
    [X, Y]    = meshgrid(1:nx, 1:ny);
    cx        = ceil(nx/2); 
    cy        = ceil(ny/2);
    R         = sqrt((X - cx).^2 + (Y - cy).^2);
    Theta     = atan2(Y - cy, X - cx); % range [-pi, pi]

    % Choose radial band
    radial_mask = (R >= r_min) & (R <= r_max);

    % Initialize angular structure factor
    S_theta     = zeros(1, num_bins);
    theta_vals  = linspace(0, pi, num_bins);

    % Loop through angle bins
    for i = 1:num_bins
        angle_start = (i-1) * pi / num_bins;
        angle_end   = i * pi / num_bins;
        angle_mask  = (Theta >= angle_start & Theta < angle_end);
        bin_mask    = radial_mask & angle_mask;
        fft_angle   = IMGFFT .* bin_mask;
        S_theta(i)  = sum(sum(abs(fft_angle).^2));
    end

    % Smooth using either Gaussian or moving average
    if exist('sigma', 'var') && ~isempty(sigma)
        % Gaussian convolution
        half_width   = ceil(3 * sigma);
        x            = -half_width:half_width;
        gauss_kernel = exp(-x.^2 / (2 * sigma^2));
        gauss_kernel = gauss_kernel / sum(gauss_kernel);
        % Circular convolution
        S_theta = conv([S_theta(end-half_width+1:end), S_theta, S_theta(1:half_width)], ...
                       gauss_kernel, 'same');
        S_theta = S_theta(half_width+1:end-half_width);
    elseif exist('windowSize', 'var') && ~isempty(windowSize)
        % Moving average via convolution (circular)
        pad = floor(windowSize / 2);
        kernel = ones(1, windowSize) / windowSize;
        S_theta = conv([S_theta(end-pad+1:end), S_theta, S_theta(1:pad)], kernel, 'same');
        S_theta = S_theta(pad+1:end-pad);
    end
end

function contrast = computeRadialSpectralContrast(IMGFFT, r_min, r_max, threshold)
    % Apply threshold to isolate strong peaks
    IMGFFT(IMGFFT < threshold) = 0;

    % Prepare polar coordinates
    [ny, nx] = size(IMGFFT);
    [X, Y]   = meshgrid(1:nx, 1:ny);
    cx       = ceil(nx/2); 
    cy       = ceil(ny/2);
    R        = sqrt((X - cx).^2 + (Y - cy).^2);

    % Ring region (annulus) mask
    ring_mask = (R >= r_min) & (R <= r_max);

    % Squared magnitude in the ring
    ring_power = abs(IMGFFT).^2 .* ring_mask;

    % Maximum power in the ring
    ring_max = max(ring_power(:));

    % Power at the DC component
    dc_power = abs(IMGFFT(cy, cx))^2;

    % Avoid division by zero
    if dc_power == 0
        contrast = Inf;  % or NaN or 0, depending on how you want to handle this
    else
        contrast = ring_max / dc_power;
    end
end

function ret = getBkgOffsetFromCorners(img, x_fraction, y_fraction)
    % image must be a 2D numerical array
    [dim1, dim2] = size(img);

    s1 = img(1:round(dim1 * y_fraction), 1:round(dim2 * x_fraction)); 
    s2 = img(1:round(dim1 * y_fraction), round(dim2 - dim2 * x_fraction):dim2);
    s3 = img(round(dim1 - dim1 * y_fraction):dim1, 1:round(dim2 * x_fraction));
    s4 = img(round(dim1 - dim1 * y_fraction):dim1, round(dim2 - dim2 * x_fraction):dim2);

    ret = mean([mean(s1(:)), mean(s2(:)), mean(s3(:)), mean(s4(:))]);
end

function ret = subtractBackgroundOffset(img, fraction)
    % Remove the background from the image.
    % :param dataArray: The image
    % :type dataArray: xarray DataArray
    % :param x_fraction: The fraction of the pixels used in x axis
    % :type x_fraction: float
    % :param y_fraction: The fraction of the pixels used in y axis
    % :type y_fraction: float
    % :return: The image after removing background
    % :rtype: xarray DataArray
    
    x_fraction = fraction(1);
    y_fraction = fraction(2);
    offset = getBkgOffsetFromCorners(img, x_fraction, y_fraction);
    ret    = img - offset;
end

function ret = cropODImage(img, center, span)
    % Crop the image according to the region of interest (ROI).
    % :param dataSet: The images
    % :type dataSet: xarray DataArray or DataSet
    % :param center: The center of region of interest (ROI)
    % :type center: tuple
    % :param span: The span of region of interest (ROI)
    % :type span: tuple
    % :return: The cropped images
    % :rtype: xarray DataArray or DataSet

    x_start = floor(center(1) - span(1) / 2);
    x_end   = floor(center(1) + span(1) / 2);
    y_start = floor(center(2) - span(2) / 2);
    y_end   = floor(center(2) + span(2) / 2);

    ret = img(y_start:y_end, x_start:x_end);
end

function imageOD = calculateODImage(imageAtom, imageBackground, imageDark, mode, exposureTime)
%CALCULATEODIMAGE Calculates the optical density (OD) image for absorption imaging.
%
%   imageOD = calculateODImage(imageAtom, imageBackground, imageDark, mode, exposureTime)
%
%   Inputs:
%       imageAtom       - Image with atoms
%       imageBackground - Image without atoms
%       imageDark       - Image without light
%       mode            - 'LowIntensity' (default) or 'HighIntensity'
%       exposureTime    - Required only for 'HighIntensity' [in seconds]
%
%   Output:
%       imageOD         - Computed OD image
%

    arguments
        imageAtom       (:,:) {mustBeNumeric}
        imageBackground (:,:) {mustBeNumeric}
        imageDark       (:,:) {mustBeNumeric}
        mode            char {mustBeMember(mode, {'LowIntensity', 'HighIntensity'})} = 'LowIntensity'
        exposureTime    double = NaN
    end

    % Compute numerator and denominator
    numerator   = imageBackground - imageDark;
    denominator = imageAtom - imageDark;

    % Avoid division by zero
    numerator(numerator == 0)     = 1;
    denominator(denominator == 0) = 1;

    % Calculate OD based on mode
    switch mode
        case 'LowIntensity'
            imageOD = -log(abs(denominator ./ numerator));
            
        case 'HighIntensity'
            if isnan(exposureTime)
                error('Exposure time must be provided for HighIntensity mode.');
            end
            imageOD = abs(denominator ./ numerator);
            imageOD = -log(imageOD) + (numerator - denominator) ./ (7000 * (exposureTime / 5e-6));
    end

end

function drawODOverlays(x1, y1, x2, y2)
    
    % Parameters
    tick_spacing = 10;   % µm between ticks
    tick_length = 2;     % µm tick mark length
    line_color = [0.5 0.5 0.5];
    tick_color = [0.5 0.5 0.5];
    font_size = 10;

    % Vector from start to end
    dx = x2 - x1;
    dy = y2 - y1;
    L = sqrt(dx^2 + dy^2);

    % Unit direction vector along diagonal
    ux = dx / L;
    uy = dy / L;

    % Perpendicular unit vector for ticks
    perp_ux = -uy;
    perp_uy = ux;

    % Midpoint (center)
    xc = (x1 + x2) / 2;
    yc = (y1 + y2) / 2;

    % Number of positive and negative ticks
    n_ticks = floor(L / (2 * tick_spacing));

    % Draw main diagonal line
    plot([x1 x2], [y1 y2], '--', 'Color', line_color, 'LineWidth', 1.2);

    for i = -n_ticks:n_ticks
        d = i * tick_spacing;
        xt = xc + d * ux;
        yt = yc + d * uy;

        % Tick line endpoints
        xt1 = xt - 0.5 * tick_length * perp_ux;
        yt1 = yt - 0.5 * tick_length * perp_uy;
        xt2 = xt + 0.5 * tick_length * perp_ux;
        yt2 = yt + 0.5 * tick_length * perp_uy;

        % Draw tick
        plot([xt1 xt2], [yt1 yt2], '--', 'Color', tick_color, 'LineWidth', 1);

        % Label: centered at tick, offset slightly along diagonal
        if d ~= 0
            text(xt, yt, sprintf('%+d', d), ...
                'Color', tick_color, ...
                'FontSize', font_size, ...
                'HorizontalAlignment', 'center', ...
                'VerticalAlignment', 'bottom', ...
                'Rotation', atan2d(dy, dx));
        end

    end
end

function drawPSOverlays(kx, ky, r_min, r_max)
% drawFFTOverlays - Draw overlays on existing FFT plot:
%   - Radial lines every 30°
%   - Annular highlight with white (upper half) and gray (lower half) circles between r_min and r_max
%   - Horizontal white bands at ky=0 in annulus region
%   - Scale ticks and labels every 1 μm⁻¹ along each radial line
%
% Inputs:
%   kx, ky  - reciprocal space vectors (μm⁻¹)
%   r_min   - inner annulus radius offset index (integer)
%   r_max   - outer annulus radius offset index (integer)
%
% Example:
%   hold on;
%   drawFFTOverlays(kx, ky, 10, 30);
    
    hold on

    % === Overlay Radial Lines + Scales ===
    [kx_grid, ky_grid] = meshgrid(kx, ky);
    [~, kr_grid] = cart2pol(kx_grid, ky_grid);  % kr_grid in μm⁻¹

    max_kx = max(kx);
    max_ky = max(ky);

    for angle = 0 : pi/6 : pi
        x_line = [0, max_kx] * cos(angle);
        y_line = [0, max_ky] * sin(angle);

        % Plot radial lines
        plot(x_line, y_line, '--', 'Color', [0.5 0.5 0.5], 'LineWidth', 1.2);
        plot(x_line, -y_line, '--', 'Color', [0.5 0.5 0.5], 'LineWidth', 1.2);

        % Draw scale ticks along positive radial line
        drawTicksAlongLine(0, 0, x_line(2), y_line(2));

        % Draw scale ticks along negative radial line (reflect y)
        drawTicksAlongLine(0, 0, x_line(2), -y_line(2));
    end

    % === Overlay Annular Highlight: White (r_min to r_max), Gray elsewhere ===
    theta_full = linspace(0, 2*pi, 500);

    center_x = ceil(size(kr_grid, 2) / 2);
    center_y = ceil(size(kr_grid, 1) / 2);

    k_min = kr_grid(center_y, center_x + r_min);
    k_max = kr_grid(center_y, center_x + r_max);

    % Upper half: white dashed circles
    x1_upper = k_min * cos(theta_full(theta_full <= pi));
    y1_upper = k_min * sin(theta_full(theta_full <= pi));
    x2_upper = k_max * cos(theta_full(theta_full <= pi));
    y2_upper = k_max * sin(theta_full(theta_full <= pi));
    plot(x1_upper, y1_upper, 'k--', 'LineWidth', 1.2);
    plot(x2_upper, y2_upper, 'k--', 'LineWidth', 1.2);

    % Lower half: gray dashed circles
    x1_lower = k_min * cos(theta_full(theta_full > pi));
    y1_lower = k_min * sin(theta_full(theta_full > pi));
    x2_lower = k_max * cos(theta_full(theta_full > pi));
    y2_lower = k_max * sin(theta_full(theta_full > pi));
    plot(x1_lower, y1_lower, '--', 'Color', [0.5 0.5 0.5], 'LineWidth', 1.0);
    plot(x2_lower, y2_lower, '--', 'Color', [0.5 0.5 0.5], 'LineWidth', 1.0);

    % === Highlight horizontal band across k_y = 0 ===
    x_vals = kx;
    xW1 = x_vals((x_vals >= -k_max) & (x_vals < -k_min));
    xW2 = x_vals((x_vals > k_min) & (x_vals <= k_max));

    plot(xW1, zeros(size(xW1)), 'k--', 'LineWidth', 1.2);
    plot(xW2, zeros(size(xW2)), 'k--', 'LineWidth', 1.2);

    hold off


    % --- Nested helper function to draw ticks along a radial line ---
    function drawTicksAlongLine(x_start, y_start, x_end, y_end)
        % Tick parameters
        tick_spacing = 1;      % spacing between ticks in μm⁻¹
        tick_length = 0.05 * sqrt((x_end - x_start)^2 + (y_end - y_start)^2); % relative tick length
        line_color = [0.5 0.5 0.5];
        tick_color = [0.5 0.5 0.5];
        font_size = 8;

        % Vector along the line
        dx = x_end - x_start;
        dy = y_end - y_start;
        L = sqrt(dx^2 + dy^2);
        ux = dx / L;
        uy = dy / L;

        % Perpendicular vector for ticks
        perp_ux = -uy;
        perp_uy = ux;

        % Number of ticks (from 0 up to max length)
        n_ticks = floor(L / tick_spacing);

        for i = 1:n_ticks
            % Position of tick along the line
            xt = x_start + i * tick_spacing * ux;
            yt = y_start + i * tick_spacing * uy;

            % Tick endpoints
            xt1 = xt - 0.5 * tick_length * perp_ux;
            yt1 = yt - 0.5 * tick_length * perp_uy;
            xt2 = xt + 0.5 * tick_length * perp_ux;
            yt2 = yt + 0.5 * tick_length * perp_uy;

            % Draw tick
            plot([xt1 xt2], [yt1 yt2], '-', 'Color', tick_color, 'LineWidth', 1);

            % Label with distance (integer)
            text(xt, yt, sprintf('%d', i), ...
                'Color', tick_color, ...
                'FontSize', font_size, ...
                'HorizontalAlignment', 'center', ...
                'VerticalAlignment', 'bottom', ...
                'Rotation', atan2d(dy, dx));
        end
    end

end

function [optrefimages] = removefringesInImage(absimages, refimages, bgmask)
    % removefringesInImage - Fringe removal and noise reduction from absorption images.
    % Creates an optimal reference image for each absorption image in a set as 
    % a linear combination of reference images, with coefficients chosen to 
    % minimize the least-squares residuals between each absorption image and 
    % the optimal reference image. The coefficients are obtained by solving a 
    % linear set of equations using matrix inverse by LU decomposition.
    %
    % Application of the algorithm is described in C. F. Ockeloen et al, Improved 
    % detection of small atom numbers through image processing, arXiv:1007.2136 (2010).
    %
    % Syntax:
    %    [optrefimages] = removefringesInImage(absimages,refimages,bgmask);
    %
    % Required inputs:
    %    absimages    - Absorption image data, 
    %                   typically 16 bit grayscale images
    %    refimages    - Raw reference image data
    %       absimages and refimages are both cell arrays containing
    %       2D array data. The number of refimages can differ from the 
    %       number of absimages.
    %
    % Optional inputs:
    %    bgmask       - Array specifying background region used, 
    %                   1=background, 0=data. Defaults to all ones.
    % Outputs:
    %    optrefimages - Cell array of optimal reference images, 
    %                   equal in size to absimages.
    %
    
    % Dependencies: none
    %
    % Authors: Shannon Whitlock, Caspar Ockeloen
    % Reference: C. F. Ockeloen, A. F. Tauschinsky, R. J. C. Spreeuw, and
    %            S. Whitlock, Improved detection of small atom numbers through 
    %            image processing, arXiv:1007.2136
    % Email: 
    % May 2009; Last revision: 11 August 2010
    
    % Process inputs
    
    % Set variables, and flatten absorption and reference images
    nimgs  = size(absimages,3);
    nimgsR = size(refimages,3);
    xdim = size(absimages(:,:,1),2);
    ydim = size(absimages(:,:,1),1);
    
    R = single(reshape(refimages,xdim*ydim,nimgsR));
    A = single(reshape(absimages,xdim*ydim,nimgs));
    optrefimages=zeros(size(absimages)); % preallocate
    
    if not(exist('bgmask','var')); bgmask=ones(ydim,xdim); end
    k = find(bgmask(:)==1);  % Index k specifying background region
    
    % Ensure there are no duplicate reference images
    % R=unique(R','rows')'; % comment this line if you run out of memory
    
    % Decompose B = R*R' using singular value or LU decomposition
    [L,U,p] = lu(R(k,:)'*R(k,:),'vector');       % LU decomposition
    
    for j=1:nimgs
        b=R(k,:)'*A(k,j);
        % Obtain coefficients c which minimise least-square residuals  
        lower.LT = true; upper.UT = true;
        c = linsolve(U,linsolve(L,b(p,:),lower),upper);
    
        % Compute optimised reference image
        optrefimages(:,:,j)=reshape(R*c,[ydim xdim]);
    end
end