286 lines
9.7 KiB
Matlab
286 lines
9.7 KiB
Matlab
%% Parameters
|
|
|
|
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 = "C:/Users/Karthik/Documents/GitRepositories/Calculations/Data-Analyzer/";
|
|
|
|
run = '0140';
|
|
|
|
cam = 4;
|
|
|
|
angle = 0;
|
|
center = [95, 1042];
|
|
span = [50, 50];
|
|
fraction = [0.1, 0.1];
|
|
|
|
pixel_size = 5.86e-6;
|
|
removeFringes = false;
|
|
|
|
%}
|
|
|
|
folderPath = "C:/Users/Karthik/Documents/GitRepositories/Calculations/Imaging-Response-Function-Extractor/";
|
|
|
|
run = '0096';
|
|
|
|
folderPath = strcat(folderPath, run);
|
|
|
|
cam = 5;
|
|
|
|
angle = 0;
|
|
center = [1137, 2023];
|
|
span = [500, 500];
|
|
fraction = [0.1, 0.1];
|
|
|
|
pixel_size = 5.86e-6;
|
|
removeFringes = false;
|
|
|
|
% 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 = im2double(imrotate(h5read(fullFileName, append(groupList(cam), "/atoms")), angle));
|
|
bkg_img = im2double(imrotate(h5read(fullFileName, append(groupList(cam), "/background")), angle));
|
|
dark_img = im2double(imrotate(h5read(fullFileName, append(groupList(cam), "/dark")), angle));
|
|
|
|
refimages(:,:,k) = subtractBackgroundOffset(cropODImage(bkg_img, center, span), fraction)';
|
|
absimages(:,:,k) = subtractBackgroundOffset(cropODImage(calculateODImage(atm_img, bkg_img, dark_img), center, span), fraction)';
|
|
|
|
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
|
|
|
|
%%
|
|
|
|
figure(1)
|
|
clf
|
|
set(gcf,'Position',[50 50 950 750])
|
|
|
|
% Calculate the x and y limits for the cropped image
|
|
y_min = center(1) - span(2) / 2;
|
|
y_max = center(1) + span(2) / 2;
|
|
x_min = center(2) - span(1) / 2;
|
|
x_max = center(2) + span(1) / 2;
|
|
|
|
% Generate x and y arrays representing the original coordinates for each pixel
|
|
x_range = linspace(x_min, x_max, span(1));
|
|
y_range = linspace(y_min, y_max, span(2));
|
|
|
|
% Display the cropped image
|
|
for k = 1 : length(od_imgs)
|
|
imagesc(x_range, y_range, od_imgs{k})
|
|
axis equal tight;
|
|
hcb = colorbar;
|
|
hL = ylabel(hcb, 'Normalised Optical Density', 'FontSize', 16);
|
|
set(hL,'Rotation',-90);
|
|
colormap jet;
|
|
set(gca,'CLim',[0 1.0]);
|
|
set(gca,'YDir','normal')
|
|
set(gca, 'YTick', linspace(y_min, y_max, 5)); % Define y ticks
|
|
set(gca, 'YTickLabel', flip(linspace(y_min, y_max, 5))); % Flip only the labels
|
|
xlabel('Horizontal', 'Interpreter', 'tex','FontSize',16);
|
|
ylabel('Vertical', 'Interpreter', 'tex','FontSize',16);
|
|
|
|
drawnow
|
|
pause(0.5)
|
|
end
|
|
|
|
%% Overlay images
|
|
|
|
% image_below = ;
|
|
% image_top = ;
|
|
|
|
% Display the first image (opaque)
|
|
figure (2);
|
|
clf
|
|
set(gcf,'Position',[50 50 950 750])
|
|
|
|
imagesc(x_range, y_range, image_below);
|
|
hold on; % Allow overlaying of the second image
|
|
h = imagesc(x_range, y_range, image_top); % Display the second image (translucent)
|
|
set(h, 'AlphaData', 0.6); % Adjust transparency: 0 is fully transparent, 1 is fully opaque
|
|
axis equal tight;
|
|
hcb = colorbar;
|
|
hL = ylabel(hcb, 'Optical Density', 'FontSize', 16);
|
|
set(hL,'Rotation',-90);
|
|
colormap jet;
|
|
set(gca,'CLim',[0 1.0]);
|
|
set(gca,'YDir','normal')
|
|
set(gca, 'YTick', linspace(y_min, y_max, 5)); % Define y ticks
|
|
set(gca, 'YTickLabel', flip(linspace(y_min, y_max, 5))); % Flip only the labels
|
|
xlabel('X', 'Interpreter', 'tex','FontSize',16);
|
|
ylabel('Y', 'Interpreter', 'tex','FontSize',16);
|
|
hold off;
|
|
|
|
%% 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 ret = calculateODImage(imageAtom, imageBackground, imageDark)
|
|
% Calculate the OD image for absorption imaging.
|
|
% :param imageAtom: The image with atoms
|
|
% :type imageAtom: numpy array
|
|
% :param imageBackground: The image without atoms
|
|
% :type imageBackground: numpy array
|
|
% :param imageDark: The image without light
|
|
% :type imageDark: numpy array
|
|
% :return: The OD images
|
|
% :rtype: numpy array
|
|
|
|
numerator = imageBackground - imageDark;
|
|
denominator = imageAtom - imageDark;
|
|
|
|
numerator(numerator == 0) = 1;
|
|
denominator(denominator == 0) = 1;
|
|
|
|
ret = -log(double(abs(denominator ./ numerator)));
|
|
|
|
if numel(ret) == 1
|
|
ret = ret(1);
|
|
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
|