577 lines
19 KiB
Matlab
577 lines
19 KiB
Matlab
%% Extract Images
|
|
clear; close all; clc;
|
|
|
|
%% ===== 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/06/24/";
|
|
|
|
run = '0001';
|
|
|
|
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:5:45
|
|
titleString = 'Droplets to Stripes';
|
|
elseif strcmp(savefileName, 'StripesToDroplets')
|
|
scan_groups = 45:-5: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
|
|
|
|
%% Carry out PCA
|
|
numPCs = 5;
|
|
|
|
% Stack all 600 images into one data matrix [nImages x nPixels]
|
|
allImgs3D = cat(3, od_imgs{:});
|
|
[Nx, Ny] = size(allImgs3D(:,:,1));
|
|
Xall = reshape(allImgs3D, [], numel(od_imgs))'; % [600 x (Nx*Ny)]
|
|
|
|
% Global PCA
|
|
[coeff, score, ~, ~, explained] = pca(Xall);
|
|
|
|
%% Visualize PC1
|
|
% Extract the first principal component vector (eigenimage)
|
|
pc1_vector = coeff(:,1);
|
|
|
|
% Reshape back to original image dimensions
|
|
pc1_image = reshape(pc1_vector, Nx, Ny);
|
|
|
|
% Plot the PC1 image
|
|
figure(1); clf; set(gcf, 'Color', 'w', 'Position', [100 100 950 750]);
|
|
imagesc(pc1_image);
|
|
axis image off;
|
|
colormap(Colormaps.coolwarm()); % or use 'jet', 'parula', etc.
|
|
colorbar;
|
|
title(sprintf('First Principal Component (PC1) Image - Explains %.2f%% Variance', explained(1)));
|
|
|
|
%% Distribution scatter plot
|
|
numGroups = numel(scan_groups);
|
|
colors = lines(numGroups);
|
|
|
|
figure(2); clf; set(gcf, 'Color', 'w', 'Position', [100 100 950 750]); hold on;
|
|
for g = 1:numGroups
|
|
idx = scan_parameter_values == scan_groups(g);
|
|
scatter(repmat(scan_groups(g), sum(idx),1), score(idx,1), 36, colors(g,:), 'filled');
|
|
end
|
|
xlabel('Control Parameter');
|
|
ylabel('PC1 Score');
|
|
title('Evolution of PC1 Scores');
|
|
grid on;
|
|
|
|
%% Distribution Histogram plot
|
|
numGroups = length(scan_groups);
|
|
colors = lines(numGroups);
|
|
|
|
% Define number of bins globally
|
|
numBins = 20;
|
|
|
|
% Define common bin edges based on global PC1 score range
|
|
minScore = min(score(:,1));
|
|
maxScore = max(score(:,1));
|
|
binEdges = linspace(minScore, maxScore, numBins+1); % +1 because edges are one more than bins
|
|
binWidth = binEdges(2) - binEdges(1); % for scaling KDE
|
|
|
|
figure(3);
|
|
clf; set(gcf, 'Color', 'w', 'Position', [100 100 950 750]);
|
|
tiledlayout(ceil(numGroups/2), 2, 'TileSpacing', 'compact', 'Padding', 'compact');
|
|
|
|
for g = 1:numGroups
|
|
groupVal = scan_groups(g);
|
|
idx = scan_parameter_values == groupVal;
|
|
groupPC1 = score(idx,1);
|
|
|
|
nexttile;
|
|
|
|
% Plot histogram
|
|
histogram(groupPC1, 'Normalization', 'probability', ...
|
|
'FaceColor', colors(g,:), 'EdgeColor', 'none', ...
|
|
'BinEdges', binEdges);
|
|
hold on;
|
|
|
|
% Compute KDE
|
|
[f, xi] = ksdensity(groupPC1, 'NumPoints', 1000);
|
|
|
|
% Scale KDE to histogram probability scale
|
|
f_scaled = f * binWidth;
|
|
|
|
% Overlay KDE curve
|
|
plot(xi, f_scaled, 'k', 'LineWidth', 1.5);
|
|
|
|
% Vertical line at median
|
|
med = median(groupPC1);
|
|
yl = ylim;
|
|
plot([med med], yl, 'k--', 'LineWidth', 1);
|
|
|
|
xlabel('PC1 Score');
|
|
ylabel('Probability');
|
|
title(sprintf('Control Parameter = %d', groupVal));
|
|
grid on;
|
|
hold off;
|
|
end
|
|
|
|
sgtitle('PC1 Score Distributions');
|
|
|
|
%% Box plot for PC1 scores by group
|
|
groupLabels = cell(size(score,1),1);
|
|
for g = 1:numGroups
|
|
idx = scan_parameter_values == scan_groups(g);
|
|
groupLabels(idx) = {sprintf('%d', scan_groups(g))};
|
|
end
|
|
|
|
figure(4);
|
|
clf; set(gcf, 'Color', 'w', 'Position', [100 100 950 750]);
|
|
boxplot(score(:,1), groupLabels);
|
|
xlabel('Control Parameter');
|
|
ylabel('PC1 Score');
|
|
title('Evolution of PC1 Scores');
|
|
grid on;
|
|
|
|
%% Mean and SEM plot for PC1 scores
|
|
numGroups = length(scan_groups);
|
|
meanPC1Scores = zeros(numGroups,1);
|
|
semPC1Scores = zeros(numGroups,1);
|
|
|
|
for g = 1:numGroups
|
|
groupVal = scan_groups(g);
|
|
idx = scan_parameter_values == groupVal;
|
|
groupPC1 = score(idx,1); % PC1 scores for this group
|
|
|
|
meanPC1Scores(g) = mean(groupPC1);
|
|
semPC1Scores(g) = std(groupPC1)/sqrt(sum(idx)); % Standard error of mean
|
|
end
|
|
|
|
% Plot mean ± SEM with error bars
|
|
figure(5);
|
|
clf; set(gcf, 'Color', 'w', 'Position', [100 100 950 750]);
|
|
errorbar(scan_groups, meanPC1Scores, semPC1Scores, 'o-', ...
|
|
'LineWidth', 1.5, 'MarkerSize', 8, 'MarkerFaceColor', 'b');
|
|
xlabel('Control Parameter');
|
|
ylabel('Mean PC1 Score ± SEM');
|
|
title('Evolution of PC1 Scores');
|
|
grid on;
|
|
|
|
%% Plot Binder Cumulant
|
|
maxOrder = 4; % We only need up to order 4 here
|
|
numGroups = length(scan_groups);
|
|
kappa4 = NaN(1, numGroups);
|
|
|
|
for g = 1:numGroups
|
|
groupVal = scan_groups(g);
|
|
idx = scan_parameter_values == groupVal;
|
|
groupPC1 = score(idx, 1);
|
|
|
|
cumulants = computeCumulants(groupPC1, maxOrder);
|
|
kappa4(g) = cumulants(4); % 4th-order cumulant
|
|
end
|
|
|
|
% Plot
|
|
figure(6);
|
|
clf; set(gcf, 'Color', 'w', 'Position', [100 100 950 750]);
|
|
plot(scan_groups, kappa4 * 1E-5, '-o', 'LineWidth', 1.5, 'MarkerFaceColor', 'b');
|
|
ylim([-12 12])
|
|
xlabel('Control Parameter');
|
|
ylabel('\kappa_4 (\times 10^{5})');
|
|
grid on;
|
|
title('Evolution of Binder Cumulant of PC1 Score');
|
|
|
|
%% --- ANOVA test ---
|
|
p = anova1(score(:,1), groupLabels, 'off');
|
|
fprintf('ANOVA p-value for PC1 score differences between groups: %.4e\n', p);
|
|
|
|
%% Helper Functions
|
|
|
|
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 [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
|
|
|