mirror of
https://github.com/cdtools-developers/cdtools.git
synced 2026-11-22 21:54:05 +01:00
move to a src directory layout
This commit is contained in:
1 parent
c3fef28314
commit
442fa2c71f
45 files changed
+19
-19
No files matched your search
@@ -0,0 +1,27 @@
|
||||
""" This module contains various packages of tools supporting common needs
|
||||
|
||||
It at times feels a bit silly to keep all the tools siloed under a particular
|
||||
subpackage such as "projectors" or "measurements", especially given that
|
||||
"flat is better than nested", but I find something comforting about the
|
||||
organization and the ability to only pull in the particular set of tools
|
||||
that one needs for a specific application.
|
||||
|
||||
The submodules are all structured as modules with their own __init__ files,
|
||||
which use an import * statement to import from a file defining the various
|
||||
functions. This is done to prevent leakage of imported packages into the
|
||||
namespace of CDTools. I know, we're all consenting adults, but I just hate
|
||||
having numpy and torch defined under CDTools.tools.cmath, you know?
|
||||
|
||||
"""
|
||||
|
||||
from CDTools.tools import losses
|
||||
from CDTools.tools import data
|
||||
from CDTools.tools import image_processing
|
||||
from CDTools.tools import initializers
|
||||
from CDTools.tools import plotting
|
||||
from CDTools.tools import interactions
|
||||
from CDTools.tools import propagators
|
||||
from CDTools.tools import measurements
|
||||
from CDTools.tools import analysis
|
||||
from CDTools.tools import atoms
|
||||
from CDTools.tools import polarization
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.analysis.analysis import *
|
||||
@@ -0,0 +1,960 @@
|
||||
"""Contains basic functions for analyzing the results of reconstructions
|
||||
|
||||
The functions in this module are designed to work either with pytorch tensors
|
||||
or numpy arrays, so they can be used either directly after reconstructions
|
||||
on the attributes of the models themselves, or after-the-fact once the
|
||||
data has been stored in numpy arrays.
|
||||
"""
|
||||
|
||||
import torch as t
|
||||
import numpy as np
|
||||
from CDTools.tools import image_processing as ip
|
||||
from scipy import fftpack
|
||||
from scipy import linalg as sla
|
||||
from scipy import special
|
||||
|
||||
__all__ = ['orthogonalize_probes', 'standardize', 'synthesize_reconstructions',
|
||||
'calc_consistency_prtf', 'calc_deconvolved_cross_correlation',
|
||||
'calc_frc', 'calc_vn_entropy', 'calc_top_mode_fraction',
|
||||
'calc_rms_error', 'calc_fidelity', 'calc_generalized_rms_error']
|
||||
|
||||
|
||||
def orthogonalize_probes(probes, density_matrix=None, keep_transform=False, normalize=False):
|
||||
"""Orthogonalizes a set of incoherently mixing probes
|
||||
|
||||
The strategy is to define a reduced orthogonal basis that spans
|
||||
all of the retrieved probes, and then build the density matrix
|
||||
defined by the probes in that basis. After diagonalization, the
|
||||
eigenvectors can be recast into the original basis and returned
|
||||
|
||||
By default, it assumes that the set of probes are defined just as
|
||||
standard incoherently mixing probe modes, and orthogonalizes them.
|
||||
However, if a density matrix is explicitly given, it will instead
|
||||
consider the problem of extracting the eigenbasis of the matrix
|
||||
probes * denstity_matrix * probes^dagger, where probes is the
|
||||
column matrix of the given probe functions. This latter problem arises
|
||||
in the generalization of the probe mixing model, and reduces to the
|
||||
simpler case when the density matrix is equal to the identity matrix
|
||||
|
||||
If the parameter "keep_transform" is set, the function will additionally
|
||||
return the matrix A such that A * ortho_probes^dagger = probes^dagger
|
||||
|
||||
If the parameter "normalize" is False (as is the default), the variation
|
||||
in intensities in the probe modes will be kept in the probe modes, as is
|
||||
natural for a purely incoherent model. If it is set to "True", the
|
||||
returned probe modes will all be normalized instead.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probes : array
|
||||
An l x n x m complex array representing a stack of probes
|
||||
density_matrix : np.array
|
||||
An optional l x l density matrix further elaborating on the state
|
||||
keep_transform : bool
|
||||
Default False, whether to return the map from probes to ortho_probes
|
||||
normalize : bool
|
||||
Default False, whether to normalize the probe modes
|
||||
|
||||
Returns
|
||||
-------
|
||||
ortho_probes: array
|
||||
An l x n x m complex array representing a stack of probes
|
||||
"""
|
||||
|
||||
try:
|
||||
probes = probes.detach().cpu().numpy()
|
||||
send_to_torch = True
|
||||
except:
|
||||
send_to_torch = False
|
||||
|
||||
# We can do the orthogonalization with an SVD, so first we have to
|
||||
# reshape the final two dimensions (the image shape) into a single
|
||||
# vectorized dimension. This matrix is probes^dagger, hence the
|
||||
# conjugation
|
||||
probes_mat = probes.reshape(probes.shape[0],
|
||||
probes.shape[1]*probes.shape[2])
|
||||
|
||||
if density_matrix is None:
|
||||
density_matrix = np.eye(probes.shape[0])
|
||||
|
||||
|
||||
# next we want to extract the eigendecomposition of the density matrix
|
||||
# itself
|
||||
w,v = sla.eigh(density_matrix)
|
||||
w = w[::-1]
|
||||
v = v[:,::-1]
|
||||
|
||||
# We do this just to avoid total failure when the density
|
||||
# matrix is not positive definite.
|
||||
# In most cases (such as when rho is generated directly from some other
|
||||
# matrix A such that rho=A A^dagger), w should never have any negative
|
||||
# entries.
|
||||
w = np.maximum(w,0)
|
||||
|
||||
B_dagger = np.dot(np.diag(np.sqrt(w)), v.conj().transpose())
|
||||
|
||||
#u,s,vh = np.linalg.svd(np.dot(B_dagger,probes_mat), full_matrices=False)
|
||||
u,s,vh = sla.svd(np.dot(B_dagger,probes_mat), full_matrices=False)
|
||||
|
||||
|
||||
if normalize:
|
||||
ortho_probes = vh.reshape(probes.shape[0],
|
||||
probes.shape[1],
|
||||
probes.shape[2])
|
||||
|
||||
B_dagger_inv = np.linalg.pinv(B_dagger)
|
||||
A = np.dot(B_dagger_inv,np.dot(u,np.diag(s)))
|
||||
#A_dagger = np.dot(np.linalg.pinv(np.diag(s)),
|
||||
# np.dot(np.transpose(u).conj(),B_dagger))
|
||||
else:
|
||||
ortho_probes = np.dot(np.diag(s),vh).reshape(probes.shape[0],
|
||||
probes.shape[1],
|
||||
probes.shape[2])
|
||||
B_dagger_inv = np.linalg.pinv(B_dagger)
|
||||
A = np.dot(B_dagger_inv,u)
|
||||
#A_dagger = np.dot(np.transpose(u).conj(),B_dagger)
|
||||
|
||||
if send_to_torch:
|
||||
ortho_probes = t.as_tensor(np.stack(ortho_probes))
|
||||
A = t.as_tensor(A)
|
||||
|
||||
if keep_transform:
|
||||
return ortho_probes, A#_dagger
|
||||
else:
|
||||
return ortho_probes
|
||||
|
||||
|
||||
def standardize(probe, obj, obj_slice=None, correct_ramp=False):
|
||||
"""Standardizes a probe and object to prepare them for comparison
|
||||
|
||||
There are a number of ambiguities in the definition of a ptychographic
|
||||
reconstruction. This function makes an explicit choice for each ambiguity
|
||||
to allow comparisons between independent reconstructions without confusing
|
||||
these ambiguities for real differences between the reconstructions.
|
||||
|
||||
The ambiguities and standardizations are:
|
||||
|
||||
1) a. Probe and object can be scaled inversely to one another
|
||||
b. So we set the probe intensity to an average per-pixel value of 1
|
||||
2) a. The probe and object can aquire equal and opposite phase ramps
|
||||
b. So we set the centroid of the FFT of the probe to zero frequency
|
||||
3) a. The probe and object can each acquire an arbitrary overall phase
|
||||
b. So we set the phase of the sum of all values of both the probe and object to 0
|
||||
|
||||
When dealing with the properties of the object, a slice is used by
|
||||
default as the edges of the object often are dominated by unphysical
|
||||
noise. The default slice is from 3/8 to 5/8 of the way across. If the
|
||||
probe is actually a stack of incoherently mixing probes, then the
|
||||
dominant probe mode (assumed to be the first in the list) is used, but
|
||||
all the probes are updated with the same factors.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probe : array
|
||||
A complex array storing a retrieved probe or stack of incoherently mixed probes
|
||||
obj : array
|
||||
A complex array storing a retrieved object
|
||||
obj_slice : slice
|
||||
Optional, a slice to take from the object for calculating normalizations
|
||||
correct_ramp : bool
|
||||
Default False, whether to correct for the relative phase ramps
|
||||
|
||||
Returns
|
||||
-------
|
||||
standardized_probe : array
|
||||
The standardized probe
|
||||
standardized_obj : array
|
||||
The standardized object
|
||||
|
||||
"""
|
||||
# First, we normalize the probe intensity to a fixed value.
|
||||
probe_np = False
|
||||
if isinstance(probe, np.ndarray):
|
||||
probe = t.as_tensor(probe, dtype=t.complex64)
|
||||
probe_np = True
|
||||
obj_np = False
|
||||
if isinstance(obj, np.ndarray):
|
||||
obj = t.as_tensor(obj,dtype=t.complex64)
|
||||
obj_np = True
|
||||
|
||||
# If this is a single probe and not a stack of probes
|
||||
if len(probe.shape) == 2:
|
||||
probe = probe[None,...]
|
||||
single_probe = True
|
||||
else:
|
||||
single_probe = False
|
||||
|
||||
normalization = t.sqrt(t.mean(t.abs(probe[0])**2))
|
||||
probe = probe / normalization
|
||||
obj = obj * normalization
|
||||
|
||||
# Default slice of the object to use for alignment, etc.
|
||||
if obj_slice is None:
|
||||
obj_slice = np.s_[(obj.shape[0]//8)*3:(obj.shape[0]//8)*5,
|
||||
(obj.shape[1]//8)*3:(obj.shape[1]//8)*5]
|
||||
|
||||
|
||||
if correct_ramp:
|
||||
# Need to check if this is actually working and, if not, why not
|
||||
center_freq = ip.centroid(t.abs(t.fft.fftshift(t.fft.fft2(probe[0]),
|
||||
dim=(-1,-2)))**2)
|
||||
center_freq -= t.div(t.tensor(probe[0].shape,dtype=t.float32),2,rounding_mode='floor')
|
||||
center_freq /= t.as_tensor(probe[0].shape,dtype=t.float32)
|
||||
|
||||
Is, Js = np.mgrid[:probe[0].shape[0],:probe[0].shape[1]]
|
||||
probe_phase_ramp = t.exp(2j * np.pi *
|
||||
(center_freq[0] * t.tensor(Is).to(t.float32) +
|
||||
center_freq[1] * t.tensor(Js).to(t.float32)))
|
||||
probe = probe * t.conj(probe_phase_ramp)
|
||||
Is, Js = np.mgrid[:obj.shape[0],:obj.shape[1]]
|
||||
obj_phase_ramp = t.exp(2j*np.pi *
|
||||
(center_freq[0] * t.tensor(Is).to(t.float32) +
|
||||
center_freq[1] * t.tensor(Js).to(t.float32)))
|
||||
obj = obj * obj_phase_ramp
|
||||
|
||||
# Then, we set them to consistent absolute phases
|
||||
|
||||
obj_angle = t.angle(t.sum(obj[obj_slice]))
|
||||
obj = obj * t.exp(-1j*obj_angle)
|
||||
|
||||
for i in range(probe.shape[0]):
|
||||
probe_angle = t.angle(t.sum(probe[i]))
|
||||
probe[i] = probe[i] * t.exp(-1j*probe_angle)
|
||||
|
||||
if single_probe:
|
||||
probe = probe[0]
|
||||
|
||||
if probe_np:
|
||||
probe = probe.detach().cpu().numpy()
|
||||
if obj_np:
|
||||
obj = obj.detach().cpu().numpy()
|
||||
|
||||
return probe, obj
|
||||
|
||||
|
||||
|
||||
def synthesize_reconstructions(probes, objects, use_probe=False, obj_slice=None, correct_ramp=False):
|
||||
"""Takes a collection of reconstructions and outputs a single synthesized probe and object
|
||||
|
||||
The function first standardizes the sets of probes and objects using the
|
||||
standardize function, passing through the relevant options. Then it
|
||||
calculates the closest overlap of subsequent frames to subpixel
|
||||
precision and uses a sinc interpolation to shift all the probes and objects
|
||||
to a common frame. Then the images are summed.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probes : list(array)
|
||||
A list of probes or stacks of probe modes
|
||||
objects : list(array)
|
||||
A list of objects
|
||||
use_probe : bool
|
||||
Default False, whether to use the probe or object for alignment
|
||||
obj_slice : slice
|
||||
Optional, A slice of the object to use for alignment and normalization
|
||||
correct_ramp : bool
|
||||
Default False, whether to correct for a relative phase ramp in the probe and object
|
||||
|
||||
Returns
|
||||
-------
|
||||
synth_probe : array
|
||||
The synthesized probe
|
||||
synth_obj : array
|
||||
The synthesized object
|
||||
obj_stack : list(array)
|
||||
A list of standardized objects, for further processing
|
||||
"""
|
||||
|
||||
# This should be cleaned up so it accepts anything array_like
|
||||
probe_np = False
|
||||
if isinstance(probes[0], np.ndarray):
|
||||
probes = [t.as_tensor(probe,dtype=t.complex64) for probe in probes]
|
||||
probe_np = True
|
||||
obj_np = False
|
||||
if isinstance(objects[0], np.ndarray):
|
||||
objects = [t.as_tensor(obj,dtype=t.complex64) for obj in objects]
|
||||
obj_np = True
|
||||
|
||||
obj_shape = np.min(np.array([obj.shape for obj in objects]),axis=0)
|
||||
objects = [obj[:obj_shape[0],:obj_shape[1]] for obj in objects]
|
||||
|
||||
if obj_slice is None:
|
||||
obj_slice = np.s_[(objects[0].shape[0]//8)*3:(objects[0].shape[0]//8)*5,
|
||||
(objects[0].shape[1]//8)*3:(objects[0].shape[1]//8)*5]
|
||||
|
||||
|
||||
|
||||
synth_probe, synth_obj = standardize(probes[0].clone(), objects[0].clone(), obj_slice=obj_slice,correct_ramp=correct_ramp)
|
||||
|
||||
obj_stack = [synth_obj]
|
||||
|
||||
for i, (probe, obj) in enumerate(zip(probes[1:],objects[1:])):
|
||||
probe, obj = standardize(probe.clone(), obj.clone(), obj_slice=obj_slice,correct_ramp=correct_ramp)
|
||||
if use_probe:
|
||||
shift = ip.find_shift(synth_probe[0],probe[0], resolution=50)
|
||||
else:
|
||||
shift = ip.find_shift(synth_obj[obj_slice],obj[obj_slice], resolution=50)
|
||||
|
||||
|
||||
obj = ip.sinc_subpixel_shift(obj,np.array(shift))
|
||||
|
||||
if len(probe.shape) == 3:
|
||||
probe = t.stack([ip.sinc_subpixel_shift(p,tuple(shift))
|
||||
for p in probe],dim=0)
|
||||
else:
|
||||
probe = ip.sinc_subpixel_shift(probe,tuple(shift))
|
||||
|
||||
synth_probe = synth_probe + probe
|
||||
synth_obj = synth_obj + obj
|
||||
obj_stack.append(obj)
|
||||
|
||||
|
||||
# If there only was one image
|
||||
try:
|
||||
i
|
||||
except:
|
||||
i = -1
|
||||
|
||||
if probe_np:
|
||||
synth_probe = synth_probe.numpy()
|
||||
if obj_np:
|
||||
synth_obj = synth_obj.numpy()
|
||||
obj_stack = [obj.numpy() for obj in obj_stack]
|
||||
|
||||
return synth_probe/(i+2), synth_obj/(i+2), obj_stack
|
||||
|
||||
|
||||
|
||||
def calc_consistency_prtf(synth_obj, objects, basis, obj_slice=None,nbins=None):
|
||||
"""Calculates a PRTF between each the individual objects and a synthesized one
|
||||
|
||||
The consistency PRTF at any given spatial frequency is defined as the ratio
|
||||
between the intensity of any given reconstruction and the intensity
|
||||
of a synthesized or averaged reconstruction at that spatial frequency.
|
||||
Typically, the PRTF is averaged over spatial frequencies with the same
|
||||
magnitude.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
synth_obj : array
|
||||
The synthesized object in the numerator of the PRTF
|
||||
objects : list(array)
|
||||
A list of objects or diffraction patterns for the denomenator of the PRTF
|
||||
basis : array
|
||||
The basis for the reconstruction array to allow output in physical unit
|
||||
obj_slice : slice
|
||||
Optional, a slice of the objects to use for calculating the PRTF
|
||||
nbins : int
|
||||
Optional, number of bins to use in the histogram. Defaults to a sensible value
|
||||
|
||||
Returns
|
||||
-------
|
||||
freqs : array
|
||||
The frequencies for the PRTF
|
||||
PRTF : array
|
||||
The values of the PRTF
|
||||
"""
|
||||
|
||||
obj_np = False
|
||||
if isinstance(objects[0], np.ndarray):
|
||||
objects = [t.as_tensor(obj, dtype=t.complex64) for obj in objects]
|
||||
obj_np = True
|
||||
if isinstance(synth_obj, np.ndarray):
|
||||
synth_obj = t.as_tensor(synth_obj, dtype=t.complex64)
|
||||
|
||||
if isinstance(basis, t.Tensor):
|
||||
basis = basis.detach().cpu().numpy()
|
||||
|
||||
if obj_slice is None:
|
||||
obj_slice = np.s_[(objects[0].shape[0]//8)*3:(objects[0].shape[0]//8)*5,
|
||||
(objects[0].shape[1]//8)*3:(objects[0].shape[1]//8)*5]
|
||||
|
||||
if nbins is None:
|
||||
nbins = np.max(synth_obj[obj_slice].shape) // 4
|
||||
|
||||
synth_fft = (t.abs(t.fft.fftshift(t.fft.fft2(synth_obj[obj_slice]), dim=(-1,-2)))**2).numpy()
|
||||
|
||||
|
||||
di = np.linalg.norm(basis[:,0])
|
||||
dj = np.linalg.norm(basis[:,1])
|
||||
|
||||
i_freqs = fftpack.fftshift(fftpack.fftfreq(synth_fft.shape[0],d=di))
|
||||
j_freqs = fftpack.fftshift(fftpack.fftfreq(synth_fft.shape[1],d=dj))
|
||||
|
||||
Js,Is = np.meshgrid(j_freqs,i_freqs)
|
||||
Rs = np.sqrt(Is**2+Js**2)
|
||||
|
||||
|
||||
synth_ints, bins = np.histogram(Rs,bins=nbins,weights=synth_fft)
|
||||
|
||||
prtfs = []
|
||||
for obj in objects:
|
||||
obj = obj[obj_slice]
|
||||
single_fft = (t.abs(t.fft.fftshift(t.fft.fft2(obj),
|
||||
dim=(-1,-2)))**2).numpy()
|
||||
single_ints, bins = np.histogram(Rs,bins=nbins,weights=single_fft)
|
||||
|
||||
prtfs.append(synth_ints/single_ints)
|
||||
|
||||
|
||||
prtf = np.mean(prtfs,axis=0)
|
||||
|
||||
if not obj_np:
|
||||
bins = t.Tensor(bins)
|
||||
prtf = t.Tensor(prtf)
|
||||
|
||||
return bins[:-1], prtf
|
||||
|
||||
|
||||
|
||||
def calc_deconvolved_cross_correlation(im1, im2, im_slice=None):
|
||||
"""Calculates a cross-correlation between two images with their autocorrelations deconvolved.
|
||||
|
||||
This is formally defined as the inverse Fourier transform of the normalized
|
||||
product of the Fourier transforms of the two images. It results in a
|
||||
kernel, whose characteristic size is related to the exactness of the
|
||||
possible alignment between the two images, on top of a random background
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im1 : array
|
||||
The first image, as a complex or real valued array
|
||||
im2 : array
|
||||
The first image, as a complex or real valued array
|
||||
im_slice : slice
|
||||
Default is from 3/8 to 5/8 across the image, a slice to use in the processing.
|
||||
|
||||
Returns
|
||||
-------
|
||||
corr : array
|
||||
The complex-valued deconvolved cross-correlation, in real space
|
||||
|
||||
"""
|
||||
|
||||
im_np = False
|
||||
if isinstance(im1, np.ndarray):
|
||||
im1 = t.as_tensor(im1)
|
||||
im_np = True
|
||||
if isinstance(im2, np.ndarray):
|
||||
im2 = t.as_tensor(im2)
|
||||
im_np = True
|
||||
|
||||
if im_slice is None:
|
||||
im_slice = np.s_[(im1.shape[0]//8)*3:(im1.shape[0]//8)*5,
|
||||
(im1.shape[1]//8)*3:(im1.shape[1]//8)*5]
|
||||
|
||||
|
||||
cor_fft = t.fft.fft2(im1[im_slice]) * \
|
||||
t.conj(t.fft.fft2(im2[im_slice]))
|
||||
|
||||
# Not sure if this is more or less stable than just the correlation
|
||||
# maximum - requires some testing
|
||||
cor = t.fft.ifft2(cor_fft / t.abs(cor_fft))
|
||||
|
||||
if im_np:
|
||||
cor = cor.numpy()
|
||||
|
||||
return cor
|
||||
|
||||
|
||||
def calc_frc(im1, im2, basis, im_slice=None, nbins=None, snr=1., limit='side'):
|
||||
"""Calculates a Fourier ring correlation between two images
|
||||
|
||||
This function requires an input of a basis to allow for FRC calculations
|
||||
to be related to physical units.
|
||||
|
||||
Like other analysis functions, this can take input in numpy or pytorch,
|
||||
and will return output in the respective format.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im1 : array
|
||||
The first image, a complex or real valued array
|
||||
im2 : array
|
||||
The first image, a complex or real valued array
|
||||
basis : array
|
||||
The basis for the images, defined as is standard for datasets
|
||||
im_slice : slice
|
||||
Default is from 3/8 to 5/8 across the image, a slice to use in the processing.
|
||||
nbins : int
|
||||
Number of bins to break the FRC up into
|
||||
snr : float
|
||||
The signal to noise ratio (for the combined information in both images) to return a threshold curve for.
|
||||
limit : str
|
||||
Default is 'side'. What is the highest frequency to calculate the FRC to? If 'side', it chooses the side of the Fourier transform, if 'corner' it goes fully to the corner.
|
||||
|
||||
Returns
|
||||
-------
|
||||
freqs : array
|
||||
The frequencies associated with each FRC value
|
||||
FRC : array
|
||||
The FRC values
|
||||
threshold : array
|
||||
The threshold curve for comparison
|
||||
|
||||
"""
|
||||
|
||||
im_np = False
|
||||
if isinstance(im1, np.ndarray):
|
||||
im1 = t.as_tensor(im1)
|
||||
im_np = True
|
||||
if isinstance(im2, np.ndarray):
|
||||
im2 = t.as_tensor(im2)
|
||||
im_np = True
|
||||
|
||||
if isinstance(basis, np.ndarray):
|
||||
basis = t.tensor(basis)
|
||||
|
||||
if im_slice is None:
|
||||
im_slice = np.s_[(im1.shape[0]//8)*3:(im1.shape[0]//8)*5,
|
||||
(im1.shape[1]//8)*3:(im1.shape[1]//8)*5]
|
||||
|
||||
if nbins is None:
|
||||
nbins = np.max(im1[im_slice].shape) // 8
|
||||
|
||||
f1 = t.fft.fftshift(t.fft.fft2(im1[im_slice]),dim=(-1,-2))
|
||||
f2 = t.fft.fftshift(t.fft.fft2(im2[im_slice]),dim=(-1,-2))
|
||||
cor_fft = f1 * t.conj(f2)
|
||||
|
||||
F1 = t.abs(f1)**2
|
||||
F2 = t.abs(f2)**2
|
||||
|
||||
|
||||
di = np.linalg.norm(basis[:,0])
|
||||
dj = np.linalg.norm(basis[:,1])
|
||||
|
||||
i_freqs = fftpack.fftshift(fftpack.fftfreq(cor_fft.shape[0],d=di))
|
||||
j_freqs = fftpack.fftshift(fftpack.fftfreq(cor_fft.shape[1],d=dj))
|
||||
|
||||
Js,Is = np.meshgrid(j_freqs,i_freqs)
|
||||
Rs = np.sqrt(Is**2+Js**2)
|
||||
|
||||
if limit.lower().strip() == 'side':
|
||||
max_i = np.max(i_freqs)
|
||||
max_j = np.max(j_freqs)
|
||||
frc_range = [0, max(max_i,max_j)]
|
||||
elif limit.lower().strip() == 'corner':
|
||||
frc_range = [0, np.max(Rs)]
|
||||
else:
|
||||
raise ValueError('Invalid FRC limit: choose "side" or "corner"')
|
||||
|
||||
numerator, bins = np.histogram(Rs, bins=nbins, range=frc_range,
|
||||
weights=cor_fft.numpy())
|
||||
denominator_F1, bins = np.histogram(Rs, bins=nbins, range=frc_range,
|
||||
weights=F1.detach().cpu().numpy())
|
||||
denominator_F2, bins = np.histogram(Rs, bins=nbins, range=frc_range,
|
||||
weights=F2.detach().cpu().numpy())
|
||||
n_pix, bins = np.histogram(Rs, bins=nbins, range=frc_range)
|
||||
|
||||
|
||||
#n_pix = n_pix / 4 # This is for an apodized image, apodized with a hann window
|
||||
|
||||
frc = np.abs(numerator) / np.sqrt(denominator_F1*denominator_F2)
|
||||
|
||||
# This moves from combined-image SNR to single-image SNR
|
||||
snr /= 2
|
||||
|
||||
# NOTE: I should update this to produce lots of different threshold curves
|
||||
# sigma, 2sigma, 3sigma, traditional FRC 1-bit, my better one, n_pix, etc.
|
||||
|
||||
threshold = (snr + (2 * np.sqrt(snr) + 1) / np.sqrt(n_pix)) / \
|
||||
(1 + snr + (2 * np.sqrt(snr)) / np.sqrt(n_pix))
|
||||
|
||||
my_threshold = np.sqrt(snr**2 + (2*snr**2 + 2*snr + 1)/n_pix) / \
|
||||
np.sqrt(snr**2 + 2 * snr + 1 + 2*snr**2 / n_pix)
|
||||
|
||||
twosigma_threshold = 2/ np.sqrt(n_pix)
|
||||
|
||||
if not im_np:
|
||||
bins = t.tensor(bins)
|
||||
frc = t.tensor(frc)
|
||||
threshold = t.tensor(threshold)
|
||||
|
||||
return bins[:-1], frc, threshold
|
||||
|
||||
|
||||
def calc_vn_entropy(matrix):
|
||||
"""Calculates the Von Neumann entropy of a density matrix
|
||||
|
||||
Will either accept a single matrix, or a stack of matrices. Matrices
|
||||
are assumed to be Hermetian and positive definite, to be well-formed
|
||||
density matrices
|
||||
|
||||
Parameters
|
||||
----------
|
||||
matrix : np.array
|
||||
The nxn matrix or lxnxn stack of matrices to calculate the entropy of
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
entropy: float or np.array
|
||||
The entropy or entropies of the arrays
|
||||
"""
|
||||
|
||||
if len(matrix.shape) == 3:
|
||||
# Get the eigenvalues
|
||||
eigs = [np.linalg.eigh(mat)[0] for mat in matrix]
|
||||
# Normalize them to match standard density matrix form
|
||||
eigs = [eig / np.sum(eig) for eig in eigs]
|
||||
# And calculate the VN entropy!
|
||||
entropies = [-np.sum(special.xlogy(eig,eig)) for eig in eigs]
|
||||
return np.array(entropies)
|
||||
else:
|
||||
eig = np.linalg.eigh(matrix)[0]
|
||||
entropy = -np.sum(special.xlogy(eig,eig))/np.sum(eig)
|
||||
return entropy
|
||||
|
||||
|
||||
def calc_top_mode_fraction(matrix):
|
||||
"""Calculates the fraction of total power in the top mode of a density matrix
|
||||
|
||||
Will either accept a single matrix, or a stack of matrices. Matrices
|
||||
are assumed to be Hermetian and positive definite, to be well-formed
|
||||
density matrices
|
||||
|
||||
Parameters
|
||||
----------
|
||||
matrix : np.array
|
||||
The nxn matrix or lxnxn stack of matrices to work from
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
entropy: float or np.array
|
||||
The fraction of power in the top mode of each matrix
|
||||
"""
|
||||
|
||||
if len(matrix.shape) == 3:
|
||||
# Get the eigenvalues
|
||||
eigs = [np.linalg.eigh(mat)[0] for mat in matrix]
|
||||
# Normalize them to match standard density matrix form
|
||||
fractions = [np.max(eig) / np.sum(eig) for eig in eigs]
|
||||
return np.array(fractions)
|
||||
else:
|
||||
eig = np.linalg.eigh(matrix)[0]
|
||||
fraction = np.max(eig) / np.sum(eig)
|
||||
return fraction
|
||||
|
||||
|
||||
def calc_rms_error(field_1, field_2, align_phases=True, normalize=False,
|
||||
dims=2):
|
||||
"""Calculates the root-mean-squared error between two complex wavefields
|
||||
|
||||
The formal definition of this function is:
|
||||
|
||||
output = norm * sqrt(mean(abs(field_1 - gamma * field_2)**2))
|
||||
|
||||
Where norm is an optional normalization factor, and gamma is an
|
||||
optional phase factor which is appropriate when the wavefields suffer
|
||||
from a global phase degeneracy as is often the case in diffractive
|
||||
imaging.
|
||||
|
||||
The normalization is defined as the square root of the total intensity
|
||||
contained in field_1, which is appropriate when field_1 represents a
|
||||
known ground truth:
|
||||
|
||||
norm = sqrt(mean(abs(field_1)**2))
|
||||
|
||||
The phase offset is an analytic expression for the phase offset which
|
||||
will minimize the RMS error between the two wavefields:
|
||||
|
||||
gamma = exp(1j * angle(sum(field_1 * conj(field_2))))
|
||||
|
||||
This implementation is stable even in cases where field_1 and field_2
|
||||
are completely orthogonal.
|
||||
|
||||
In the definitions above, the field_n are n-dimensional wavefields. The
|
||||
dimensionality of the wavefields can be altered via the dims argument,
|
||||
but the default is 2 for a 2D wavefield.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
field_1 : array
|
||||
The first complex-valued field
|
||||
field_2 : array
|
||||
The second complex-valued field
|
||||
align_phases : bool
|
||||
Default is True, whether to account for a global phase offset
|
||||
normalize : bool
|
||||
Default is False, whether to normalize to the intensity of field_1
|
||||
dims : (int or tuple of python:ints)
|
||||
Default is 2, the number of final dimensions to reduce over.
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
rms_error : float or t.Tensor
|
||||
The RMS error, or tensor of RMS errors, depending on the dim argument
|
||||
|
||||
"""
|
||||
|
||||
sumdims = tuple(d - dims for d in range(dims))
|
||||
|
||||
if align_phases:
|
||||
# Keepdim allows us to broadcast the result correctly when we
|
||||
# multiply by the fields
|
||||
gamma = t.exp(1j * t.angle(t.sum(field_1 * t.conj(field_2), dim=sumdims,
|
||||
keepdim=True)))
|
||||
else:
|
||||
gamma = 1
|
||||
|
||||
if normalize:
|
||||
norm = 1 / t.mean(t.abs(field_1)**2, dim=sumdims)
|
||||
else:
|
||||
norm = 1
|
||||
|
||||
difference = field_1 - gamma * field_2
|
||||
|
||||
return t.sqrt(norm * t.mean(t.abs(difference)**2, dim=sumdims))
|
||||
|
||||
|
||||
def calc_fidelity(fields_1, fields_2, dims=2):
|
||||
"""Calculates the fidelity between two density matrices
|
||||
|
||||
The fidelity is a comparison metric between two density matrices
|
||||
(i.e. mutual coherence functions) that extends the idea of the
|
||||
overlap to incoherent light. As a reminder, the overlap between two
|
||||
fields is:
|
||||
|
||||
overlap = abs(sum(field_1 * field_2))**2
|
||||
|
||||
Whereas the fidelity is defined as:
|
||||
|
||||
fidelity = trace(sqrt(sqrt(dm_1) <dot> dm_2 <dot> sqrt(dm_1)))**2
|
||||
|
||||
where dm_n refers to the density matrix encoded by fields_n such
|
||||
that dm_n = fields_n <dot> fields_<n>.conjtranspose(), sqrt
|
||||
refers to the matrix square root, and <dot> is the matrix product.
|
||||
|
||||
This is not a practical implementation, however, as it is not feasible
|
||||
to explicitly construct the matrices dm_1 and dm_2 in memory. Therefore,
|
||||
we take advantage of the alternate definition based directly on the
|
||||
fields_<n> parameter:
|
||||
|
||||
fidelity = sum(svdvals(fields_1 <dot> fields_2.conjtranspose()))**2
|
||||
|
||||
In the definitions above, the fields_n are regarded as collections of
|
||||
wavefields, where each wavefield is by default 2-dimensional. The
|
||||
dimensionality of the wavefields can be altered via the dims argument,
|
||||
but the fields_n arguments must always have at least one more dimension
|
||||
than the dims argument. Any additional dimensions are treated as batch
|
||||
dimensions.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fields_1 : array
|
||||
The first set of complex-valued field modes
|
||||
fields_2 : array
|
||||
The second set of complex-valued field modes
|
||||
dims : int
|
||||
Default is 2, the number of final dimensions to reduce over.
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
fidelity : float or t.Tensor
|
||||
The fidelity, or tensor of fidelities, depending on the dim argument
|
||||
|
||||
"""
|
||||
|
||||
fields_1 = t.as_tensor(fields_1)
|
||||
fields_2 = t.as_tensor(fields_2)
|
||||
|
||||
mult = fields_1.unsqueeze(-dims-2) * fields_2.unsqueeze(-dims-1).conj()
|
||||
sumdims = tuple(d - dims for d in range(dims))
|
||||
mat = t.sum(mult,dim=sumdims)
|
||||
|
||||
# Because I think this is the nuclear norm squared, I would like to swap
|
||||
# Out the definition for this, but I need to test it before swapping.
|
||||
# It also probably makes sense to implement sqrt_fidelity separately
|
||||
# because that's more important
|
||||
#return t.linalg.matrix_norm(mat, ord='nuc')**2
|
||||
|
||||
# I think this is just the nuclear norm.
|
||||
svdvals = t.linalg.svdvals(mat)
|
||||
return t.sum(svdvals, dim=-1)**2
|
||||
|
||||
|
||||
def calc_generalized_rms_error(fields_1, fields_2, normalize=False, dims=2):
|
||||
"""Calculates a generalization of the root-mean-squared error between two complex wavefields
|
||||
|
||||
This function calculates an generalization of the RMS error which uses the
|
||||
concept of fidelity to extend it to capture the error between
|
||||
incoherent wavefields, defined as a mode decomposition. The extension has
|
||||
several nice properties, in particular:
|
||||
|
||||
1) For coherent wavefields, it precisely matches the RMS error including
|
||||
a correction for the global phase degeneracy (align_phases=True)
|
||||
2) All mode decompositions of either field that correspond to the same
|
||||
density matrix / mutual coherence function will produce the same
|
||||
output
|
||||
3) The error will only be zero when comparing mode decompositions that
|
||||
correspond to the same density matrix.
|
||||
4) Due to (2), one need not worry about the ordering of the modes,
|
||||
properly orthogonalizing the modes, and it is even possible to
|
||||
compare mode decompositions with different numbers of modes.
|
||||
|
||||
The formal definition of this function is:
|
||||
|
||||
output = norm * sqrt(mean(abs(fields_1)**2)
|
||||
+ mean(abs(fields_2)**2)
|
||||
- 2 * sqrt(fidelity(fields_1,fields_2)))
|
||||
|
||||
Where norm is an optional normalization factor, and the fidelity is
|
||||
defined based on the mean, rather than the sum, to match the convention
|
||||
for the root *mean* squared error.
|
||||
|
||||
The normalization is defined as the square root of the total intensity
|
||||
contained in fields_1, which is appropriate when fields_1 represents a
|
||||
known ground truth:
|
||||
|
||||
norm = sqrt(mean(abs(fields_1)**2))
|
||||
|
||||
In the definitions above, the fields_n are regarded as collections of
|
||||
wavefields, where each wavefield is by default 2-dimensional. The
|
||||
dimensionality of the wavefields can be altered via the dims argument,
|
||||
but the fields_n arguments must always have at least one more dimension
|
||||
than the dims argument. Any additional dimensions are treated as batch
|
||||
dimensions.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
fields_1 : array
|
||||
The first set of complex-valued field modes
|
||||
fields_2 : array
|
||||
The second set of complex-valued field modes
|
||||
normalize : bool
|
||||
Default is False, whether to normalize to the intensity of fields_1
|
||||
dims : (int or tuple of python:ints)
|
||||
Default is 2, the number of final dimensions to reduce over.
|
||||
|
||||
Returns
|
||||
-------
|
||||
rms_error : float or t.Tensor
|
||||
The generalized RMS error, or tensor of generalized RMS errors, depending on the dim argument
|
||||
|
||||
"""
|
||||
fields_1 = t.as_tensor(fields_1)
|
||||
fields_2 = t.as_tensor(fields_2)
|
||||
|
||||
npix = t.prod(t.as_tensor(fields_1.shape[-dims:],dtype=t.int32))
|
||||
|
||||
sumdims = tuple(d - dims - 1 for d in range(dims+1))
|
||||
fields_1_intensity = t.sum(t.abs(fields_1)**2,dim=sumdims) / npix
|
||||
fields_2_intensity = t.sum(t.abs(fields_2)**2,dim=sumdims) / npix
|
||||
fidelity = calc_fidelity(fields_1, fields_2, dims=dims) / npix**2
|
||||
|
||||
result = fields_1_intensity + fields_2_intensity - 2 * t.sqrt(fidelity)
|
||||
|
||||
if normalize:
|
||||
result /= fields_1_intensity
|
||||
|
||||
return t.sqrt(result)
|
||||
|
||||
|
||||
def calc_generalized_frc(fields_1, fields_2, basis, im_slice=None, nbins=None, snr=1.):
|
||||
"""Calculates a Fourier ring correlation between two images
|
||||
|
||||
This function requires an input of a basis to allow for FRC calculations
|
||||
to be related to physical units.
|
||||
|
||||
Like other analysis functions, this can take input in numpy or pytorch,
|
||||
and will return output in the respective format.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im1 : array
|
||||
The first image, a complex or real valued array
|
||||
im2 : array
|
||||
The first image, a complex or real valued array
|
||||
basis : array
|
||||
The basis for the images, defined as is standard for datasets
|
||||
im_slice : slice
|
||||
Default is from 3/8 to 5/8 across the image, a slice to use in the processing.
|
||||
nbins : int
|
||||
Number of bins to break the FRC up into
|
||||
snr : float
|
||||
The signal to noise ratio (for the combined information in both images) to return a threshold curve for.
|
||||
|
||||
Returns
|
||||
-------
|
||||
freqs : array
|
||||
The frequencies associated with each FRC value
|
||||
FRC : array
|
||||
The FRC values
|
||||
threshold : array
|
||||
The threshold curve for comparison
|
||||
|
||||
"""
|
||||
|
||||
im_np = False
|
||||
if isinstance(fields_1, np.ndarray):
|
||||
fields_1 = t.as_tensor(fields_)
|
||||
im_np = True
|
||||
if isinstance(fields_2, np.ndarray):
|
||||
fields_2 = t.as_tensor(fields_2)
|
||||
im_np = True
|
||||
|
||||
if isinstance(basis, np.ndarray):
|
||||
basis = t.tensor(basis)
|
||||
|
||||
if im_slice is None:
|
||||
im_slice = np.s_[(im1.shape[0]//8)*3:(im1.shape[0]//8)*5,
|
||||
(im1.shape[1]//8)*3:(im1.shape[1]//8)*5]
|
||||
|
||||
if nbins is None:
|
||||
nbins = np.max(fields_1[...,im_slice].shape[-2:]) // 4
|
||||
|
||||
|
||||
f1 = t.fft.fftshift(t.fft.fft2(im1[im_slice]),dim=(-1,-2))
|
||||
f2 = t.fft.fftshift(t.fft.fft2(im2[im_slice]),dim=(-1,-2))
|
||||
cor_fft = f1 * t.conj(f2)
|
||||
|
||||
|
||||
F1 = t.abs(f1)**2
|
||||
F2 = t.abs(f2)**2
|
||||
|
||||
|
||||
di = np.linalg.norm(basis[:,0])
|
||||
dj = np.linalg.norm(basis[:,1])
|
||||
|
||||
i_freqs = fftpack.fftshift(fftpack.fftfreq(cor_fft.shape[0],d=di))
|
||||
j_freqs = fftpack.fftshift(fftpack.fftfreq(cor_fft.shape[1],d=dj))
|
||||
|
||||
Js,Is = np.meshgrid(j_freqs,i_freqs)
|
||||
Rs = np.sqrt(Is**2+Js**2)
|
||||
|
||||
# This line is used to get a set of bins that matches the logic
|
||||
# used by np.histogram, so that this function will match the choices
|
||||
# of bin edges that comes from the non-generalized version. This also
|
||||
# gets us the count on the number of pixels per bin so we can calculate
|
||||
# the threshold curve
|
||||
n_pix, bins = np.histogram(Rs,bins=nbins)
|
||||
|
||||
frc = []
|
||||
for i in range(len(bins)-1):
|
||||
mask = t.logical_and(Rs<bins[i+1], Rs>=bins[i])
|
||||
masked_f1 = f1 * mask[...,:,:]
|
||||
masked_f2 = f2 * mask[...,:,:]
|
||||
numerator = t.sqrt(calc_fidelity(masked_f1, masked_f2))
|
||||
denominator_f1 = t.sqrt(calc_fidelity(masked_f1, masked_f1))
|
||||
denominator_f2 = t.sqrt(calc_fidelity(masked_f2, masked_f2))
|
||||
frc.append(numerator / t.sqrt((denominator_f1 * denominator_f2)))
|
||||
|
||||
frc = np.array(frc)
|
||||
|
||||
# This moves from combined-image SNR to single-image SNR
|
||||
snr /= 2
|
||||
|
||||
threshold = (snr + (2 * snr + 1) / np.sqrt(n_pix)) / \
|
||||
(1 + snr + (2 * np.sqrt(snr)) / np.sqrt(n_pix))
|
||||
|
||||
if not im_np:
|
||||
bins = t.tensor(bins)
|
||||
frc = t.tensor(frc)
|
||||
threshold = t.tensor(threshold)
|
||||
|
||||
return bins[:-1], frc, threshold
|
||||
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.atoms.atoms import *
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1 @@
|
||||
from CDTools.tools.data.data import *
|
||||
@@ -0,0 +1,781 @@
|
||||
"""Contains the base functions for loading and saving data from/to .cxi files
|
||||
|
||||
These functions are used when constructing a new dataset class to pull
|
||||
specific desired information from a .cxi file. These functions should
|
||||
handle all the needed conversions between standard formats (for example,
|
||||
transposes of the basis arrays, shifting from object to probe motion, etc).
|
||||
"""
|
||||
|
||||
import h5py
|
||||
import numpy as np
|
||||
import numbers
|
||||
import datetime
|
||||
import dateutil.parser
|
||||
import torch as t
|
||||
from contextlib import contextmanager
|
||||
|
||||
__all__ = ['get_entry_info',
|
||||
'get_sample_info',
|
||||
'get_wavelength',
|
||||
'get_detector_geometry',
|
||||
'get_mask',
|
||||
'get_dark',
|
||||
'get_data',
|
||||
'get_shot_to_shot_info',
|
||||
'get_ptycho_translations',
|
||||
'create_cxi',
|
||||
'add_entry_info',
|
||||
'add_sample_info',
|
||||
'add_source',
|
||||
'add_detector',
|
||||
'add_mask',
|
||||
'add_dark',
|
||||
'add_data',
|
||||
'add_shot_to_shot_info',
|
||||
'add_ptycho_translations']
|
||||
|
||||
|
||||
#
|
||||
# Functions to inspect the basic attributes of a cxi file represented as an
|
||||
# h5 file object
|
||||
#
|
||||
|
||||
|
||||
def get_entry_info(cxi_file):
|
||||
"""Returns a dictionary with the basic metadata from the cxi file's entry_1 attribute
|
||||
|
||||
String type metadata is read out as a string, and datetime metadata
|
||||
is converted to python datetime objects if the string is properly
|
||||
formatted.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
|
||||
Returns
|
||||
-------
|
||||
entry_info : dict
|
||||
A dictionary with basic metadata defined in the cxi file
|
||||
|
||||
"""
|
||||
e1 = cxi_file['entry_1']
|
||||
metadata_attrs = ['title',
|
||||
'experiment_identifier',
|
||||
'experiment_description',
|
||||
'program_name',
|
||||
'start_time',
|
||||
'end_time']
|
||||
metadata = {attr: str(e1[attr][()].decode()) for attr in metadata_attrs
|
||||
if attr in e1}
|
||||
|
||||
|
||||
for attr in metadata_attrs:
|
||||
if attr in e1:
|
||||
try:
|
||||
metadata[attr] = dateutil.parser.parse(str(e1[attr][()].decode()))
|
||||
except ValueError:
|
||||
metadata[attr] = str(e1[attr][()].decode())
|
||||
return metadata
|
||||
|
||||
|
||||
def get_sample_info(cxi_file):
|
||||
"""Returns a dictionary with the basic metadata from the cxi file's entry_1/sample_1 attribute
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
|
||||
Returns
|
||||
-------
|
||||
sample_info : dict
|
||||
A dictionary with basic metadata from the sample defined in the cxi file
|
||||
|
||||
"""
|
||||
if 'entry_1/sample_1' not in cxi_file:
|
||||
return None
|
||||
|
||||
s1 = cxi_file['entry_1/sample_1']
|
||||
metadata_attrs = ['name','description','unit_cell_group']
|
||||
|
||||
metadata = {}
|
||||
for attr in metadata_attrs:
|
||||
# Somehow different ways of saving can lead to different ways to
|
||||
# decode it here, so we try both
|
||||
if attr in s1:
|
||||
try:
|
||||
metadata[attr] = str(s1[attr][()].decode())
|
||||
except AttributeError as e:
|
||||
metadata[attr] = str(np.array(s1[attr][:])[0].decode())
|
||||
|
||||
float_attrs = ['concentration',
|
||||
'mass',
|
||||
'temperature',
|
||||
'thickness',
|
||||
'unit_cell_volume']
|
||||
|
||||
for attr in float_attrs:
|
||||
if attr in s1:
|
||||
metadata[attr] = np.float32(s1[attr][()])
|
||||
|
||||
if 'unit_cell' in s1:
|
||||
metadata['unit_cell'] = np.array(s1['unit_cell']).astype(np.float32)
|
||||
|
||||
|
||||
if 'geometry_1/orientation' in s1:
|
||||
orient = np.array(s1['geometry_1/orientation']).astype(np.float32)
|
||||
xvec = orient[:3] / np.linalg.norm(orient[:3])
|
||||
yvec = orient[3:] / np.linalg.norm(orient[3:])
|
||||
metadata['orientation'] = np.array([xvec,yvec,
|
||||
np.cross(xvec,yvec)])
|
||||
|
||||
if 'geometry_1/surface_normal' in s1:
|
||||
snorm = np.array(s1['geometry_1/surface_normal']).astype(np.float32)
|
||||
xvec = np.cross(np.array([0.,1.,0.]), snorm)
|
||||
xvec /= np.linalg.norm(xvec)
|
||||
yvec = np.cross(snorm, xvec)
|
||||
yvec /= np.linalg.norm(yvec)
|
||||
metadata['orientation'] = np.array([xvec, yvec, snorm])
|
||||
|
||||
# Check if the metadata is empty
|
||||
if metadata == {}:
|
||||
metadata = None
|
||||
|
||||
return metadata
|
||||
|
||||
|
||||
def get_wavelength(cxi_file):
|
||||
"""Returns the wavelength of the source defined in the cxi file object, in m
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
|
||||
Returns
|
||||
-------
|
||||
wavelength: np.float32
|
||||
The wavelength of the source defined in the cxi file
|
||||
"""
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'source_1/wavelength' in i1:
|
||||
wavelength = np.float32(i1['source_1/wavelength'])
|
||||
elif 'source_1/energy' in i1:
|
||||
energy = np.float32(i1['source_1/energy'])
|
||||
wavelength = 1.9864459e-25 / energy
|
||||
else:
|
||||
raise KeyError('Neither Wavelength or Energy Defined in provided .cxi File')
|
||||
|
||||
return wavelength
|
||||
|
||||
|
||||
def get_detector_geometry(cxi_file):
|
||||
"""Returns a standardized description of the detector geometry defined in the cxi file object
|
||||
|
||||
It makes intelligent assumptions based on the definitions in the cxi
|
||||
file definition. The standardized description of the geometry that it
|
||||
outputs includes the sample to detector distance, the corner location
|
||||
of the detector, and the basis vectors defining the detector. It can
|
||||
only handle detectors defined as rectangular grids of pixels.
|
||||
|
||||
The distance and corner_location values are technically overdetermining
|
||||
the detector location, but for many experiments (particularly
|
||||
transmission experiments), the distance is needed and the exact
|
||||
corner location is not. If the corner location is not reported in
|
||||
the cxi file, no attempt will be made to calculate it.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
|
||||
Returns
|
||||
-------
|
||||
distance : np.float32
|
||||
The sample to detector distance, in m
|
||||
basis_vectors : np.array
|
||||
The basis vectors for the detector
|
||||
corner_location : np.array
|
||||
The real-space location of the (0,0) pixel in the detector
|
||||
|
||||
"""
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
d1 = i1['detector_1']
|
||||
|
||||
if 'detector_1/basis_vectors' in i1:
|
||||
basis_vectors = np.array(d1['basis_vectors'])
|
||||
if basis_vectors.shape == (2,3):
|
||||
basis_vectors = basis_vectors.T
|
||||
else:
|
||||
# This whole thing just to account for all the ways people can
|
||||
# implicitly define the x or y pixel size for a detector. I've
|
||||
# seen too many of these in the wild, unfortunately...
|
||||
try:
|
||||
x_pixel_size = np.float32(d1['x_pixel_size'])
|
||||
except:
|
||||
x_pixel_size = None
|
||||
try:
|
||||
y_pixel_size = np.float32(d1['y_pixel_size'])
|
||||
except:
|
||||
y_pixel_size = None
|
||||
|
||||
if x_pixel_size is None and y_pixel_size is not None:
|
||||
x_pixel_size = y_pixel_size
|
||||
elif x_pixel_size is not None and y_pixel_size is None:
|
||||
y_pixel_size = x_pixel_size
|
||||
if x_pixel_size is None and y_pixel_size is None:
|
||||
raise KeyError('Detector pixel size not defined in file.')
|
||||
basis_vectors = np.array([[0,-y_pixel_size,0],
|
||||
[-x_pixel_size,0,0]]).transpose()
|
||||
|
||||
try:
|
||||
distance = np.float32(d1['distance'])
|
||||
except:
|
||||
distance = None
|
||||
try:
|
||||
corner_position = np.array(d1['corner_position'])
|
||||
except:
|
||||
corner_position = None
|
||||
|
||||
# Don't pretend to calculate corner position from distance if it's not
|
||||
# defined, but do calculate distance from corner position if distance is
|
||||
# not defined. If neither is defined, then raise an error.
|
||||
if distance is None and corner_position is not None:
|
||||
detector_normal = np.cross(basis_vectors[:,0],
|
||||
basis_vectors[:,1])
|
||||
detector_normal /= np.linalg.norm(detector_normal)
|
||||
distance = np.linalg.norm(np.dot(corner_position, detector_normal))
|
||||
|
||||
if distance is None and corner_position is None:
|
||||
raise KeyError('Neither sample to detector distance nor corner position is defined in file.')
|
||||
|
||||
return distance, basis_vectors, corner_position
|
||||
|
||||
|
||||
def get_mask(cxi_file):
|
||||
"""Returns the detector mask defined in the cxi file object
|
||||
|
||||
This function converts from the format specified in the cxi file
|
||||
definition to a simple on/off mask, where a value of 1 defines a
|
||||
good pixel (on) and a value of 0 defines a bad pixel (off).
|
||||
|
||||
If any bit is set in the mask at all, it will be defined as a bad
|
||||
pixel, with the exception of pixels marked exactly as 0x00001000,
|
||||
which is defined to mean that the pixel has signal above the
|
||||
background. These pixels are treated as on pixels.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
|
||||
Returns
|
||||
-------
|
||||
mask : np.array
|
||||
An array storing the mask from the cxi file
|
||||
"""
|
||||
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'detector_1/mask' in i1:
|
||||
mask = np.array(i1['detector_1/mask']).astype(np.uint32)
|
||||
mask_on = np.equal(mask,np.uint32(0))
|
||||
mask_has_signal = np.equal(mask,np.uint32(0x00001000))
|
||||
return np.logical_or(mask_on,mask_has_signal).astype(bool)
|
||||
else:
|
||||
return None
|
||||
|
||||
|
||||
def get_dark(cxi_file):
|
||||
"""Returns an array with a dark image to use for initialization of a background model
|
||||
|
||||
This looks for a set of dark images at
|
||||
entry_1/instrument_1/detector_1/data_dark. If the darks exist, it will
|
||||
return the mean of the array along all axes but the last two. That is,
|
||||
if the dark image is a single image, it will return that image. If it
|
||||
is a stack of images, it will return the mean along the stack axis.
|
||||
|
||||
If the darks do not exist, it will return None.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
|
||||
Returns
|
||||
-------
|
||||
dark : np.array
|
||||
An array storing the dark image
|
||||
"""
|
||||
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'detector_1/data_dark' in i1:
|
||||
darks = np.array(i1['detector_1/data_dark'])
|
||||
dims = tuple(range(len(darks.shape) - 2))
|
||||
darks = np.nanmean(darks,axis=dims)
|
||||
else:
|
||||
darks = None
|
||||
|
||||
return darks
|
||||
|
||||
|
||||
def get_data(cxi_file, cut_zeros = True):
|
||||
"""Returns an array with the full stack of detector data defined in the cxi file object
|
||||
|
||||
This function will make sure to check all the various places that it's
|
||||
okay to store the data in, to ensure that it can find the data regardless
|
||||
of whether the creator of the .cxi file has remembered to link the data
|
||||
to all the required locations.
|
||||
|
||||
It will return the data array in whatever shape it's defined in.
|
||||
|
||||
It will also read out the axes attribute of the data into a list of strings.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
cut_zeros : bool
|
||||
Default True, whether to set all negative data to zero
|
||||
|
||||
Returns
|
||||
-------
|
||||
data : np.array
|
||||
An array storing the data defined in the cxi file
|
||||
axes : list(str)
|
||||
A list of the axes defined in the axes attribute, if any
|
||||
"""
|
||||
|
||||
# Possible locations for the data
|
||||
if 'entry_1/data_1/data' in cxi_file:
|
||||
pull_from = 'entry_1/data_1/data'
|
||||
elif 'entry_1/instrument_1/detector_1/data' in cxi_file:
|
||||
pull_from = 'entry_1/instrument_1/detector_1/data'
|
||||
else:
|
||||
raise KeyError('Data is not defined within cxi file')
|
||||
|
||||
data = cxi_file[pull_from][:]
|
||||
# Use maximum in-place to avoid allocating any more memory than is needed
|
||||
if cut_zeros:
|
||||
np.maximum(data,0,data)
|
||||
|
||||
if 'axes' in cxi_file[pull_from].attrs:
|
||||
try:
|
||||
axes = str(cxi_file[pull_from].attrs['axes'].decode()).split(':')
|
||||
except AttributeError as e: # Weird string vs bytes thing, ehhh
|
||||
axes = str(cxi_file[pull_from].attrs['axes']).split(':')
|
||||
|
||||
axes = [axis.strip().lower() for axis in axes]
|
||||
else:
|
||||
axes = None
|
||||
|
||||
return data, axes
|
||||
|
||||
|
||||
def get_shot_to_shot_info(cxi_file, field_name):
|
||||
"""Gets a specified dataset of shot-to-shot information from the cxi file
|
||||
|
||||
The data is assumed to be in the form of an array, with one dimension
|
||||
being the number of patterns being stored in the dataset. This is
|
||||
helpful for storing additional readback data on the shot-to-shot
|
||||
level that may be important but doens't have a clearly defined
|
||||
place to be stored in the .cxi file specification. Such data includes
|
||||
shot-to-shot probe intensity measurements, polarizer positions, etc.
|
||||
|
||||
It will look for this data in 3 places (in the following order):
|
||||
|
||||
1) entry_1/data_1/<field_name>
|
||||
2) entry_1/sample_1/geometry_1/<field_name>
|
||||
3) entry_1/instrument_1/detector_1/<field_name>
|
||||
|
||||
This function is also used internally to read out the translations
|
||||
associated with a ptychography experiment
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
field_name : str
|
||||
The name of the field to be read from
|
||||
|
||||
Returns
|
||||
-------
|
||||
data : np.array
|
||||
An array storing the translations defined in the cxi file
|
||||
"""
|
||||
if 'entry_1/data_1/' + field_name in cxi_file:
|
||||
pull_from = 'entry_1/data_1/' + field_name
|
||||
elif 'entry_1/sample_1/geometry_1/' + field_name in cxi_file:
|
||||
pull_from = 'entry_1/sample_1/geometry_1/' + field_name
|
||||
elif 'entry_1/instrument_1/detector_1/' in cxi_file:
|
||||
pull_from = 'entry_1/instrument_1/detector_1/' + field_name
|
||||
else:
|
||||
raise KeyError('Data is not defined within cxi file')
|
||||
|
||||
return np.array(cxi_file[pull_from]).astype(np.float32)
|
||||
|
||||
|
||||
def get_ptycho_translations(cxi_file):
|
||||
"""Gets an array of x,y,z translations, if such an array has been defined in the file
|
||||
|
||||
It negates the translations, because the CXI file format is designed
|
||||
to specify translations of the samples and the CDTools code specifies
|
||||
translations of the optics.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
A file object to be read
|
||||
|
||||
Returns
|
||||
-------
|
||||
translations : np.array
|
||||
An array storing the translations defined in the cxi file
|
||||
"""
|
||||
|
||||
translations = get_shot_to_shot_info(cxi_file, 'translation')
|
||||
return -translations
|
||||
|
||||
|
||||
#
|
||||
# Now we move on to the helper functions for writing CXI files
|
||||
#
|
||||
|
||||
|
||||
def create_cxi(filename):
|
||||
"""Creates a new cxi file with a single entry group
|
||||
|
||||
Parameters
|
||||
----------
|
||||
filename : str
|
||||
The path at which to create the file
|
||||
"""
|
||||
file_obj = h5py.File(filename,'w')
|
||||
file_obj.create_dataset('cxi_version', data=160)
|
||||
file_obj.create_dataset('number_of_entries',data=1)
|
||||
e1f = file_obj.create_group('entry_1')
|
||||
return file_obj
|
||||
|
||||
|
||||
def add_entry_info(cxi_file, metadata):
|
||||
"""Adds a dictionary of entry metadata to the entry_1 group of a cxi file object
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the info to
|
||||
metadata : dict
|
||||
A dictionary containing all the metadata to be stored
|
||||
"""
|
||||
# Just the string and datetime types should be relevant but all are
|
||||
# included in case the cxi spec becomes more permissive
|
||||
for key, value in metadata.items():
|
||||
if isinstance(value,(str,bytes)):
|
||||
cxi_file['entry_1'][key] = np.string_(value)
|
||||
elif isinstance(value, datetime.datetime):
|
||||
cxi_file['entry_1'][key] = np.string_(value.isoformat())
|
||||
elif isinstance(value, numbers.Number):
|
||||
cxi_file['entry_1'][key] = value
|
||||
elif isinstance(value, (np.ndarray,list,tuple)):
|
||||
cxi_file['entry_1'].create_dataset(key, data=np.asarray(value))
|
||||
elif isinstance(value, t.Tensor):
|
||||
asnumpy = value.detach().cpu().numpy()
|
||||
cxi_file['entry_1'].create_dataset(key, data=asnumpy)
|
||||
|
||||
|
||||
|
||||
def add_sample_info(cxi_file, metadata):
|
||||
"""Adds a dictionary of entry metadata to the entry_1/sample_1 group of a cxi file object
|
||||
|
||||
This function will create the sample_1 attribute if it doesn't already exist
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the info to
|
||||
metadata : dict
|
||||
A dictionary containing all the metadata to be stored
|
||||
"""
|
||||
if 'entry_1/sample_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('sample_1')
|
||||
s1 = cxi_file['entry_1/sample_1']
|
||||
|
||||
if 'orientation' in metadata:
|
||||
if 'geometry_1' not in s1:
|
||||
s1.create_group('geometry_1')
|
||||
# Only store the part of this matrix as defined in the CXI file spec
|
||||
s1['geometry_1'].create_dataset('orientation',
|
||||
data=metadata['orientation'].ravel()[:6])
|
||||
|
||||
for key, value in metadata.items():
|
||||
if key == 'orientation':
|
||||
continue # this is a special case
|
||||
if isinstance(value,(str,bytes)):
|
||||
s1[key] = np.string_(value)
|
||||
elif isinstance(value, datetime.datetime):
|
||||
s1[key] = np.string_(value.isoformat())
|
||||
elif isinstance(value, numbers.Number):
|
||||
s1[key] = value
|
||||
elif isinstance(value, (np.ndarray,list,tuple)):
|
||||
s1.create_dataset(key, data=np.asarray(value))
|
||||
elif isinstance(value, t.Tensor):
|
||||
asnumpy = value.detach().cpu().numpy()
|
||||
s1.create_dataset(key, data=asnumpy)
|
||||
|
||||
|
||||
def add_source(cxi_file, wavelength):
|
||||
"""Adds the entry_1/source_1 group to a cxi file object
|
||||
|
||||
It stores the energy and wavelength attributes in the source_1 group,
|
||||
given a wavelength to define them from.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the source to
|
||||
wavelength : float
|
||||
The wavelength of light
|
||||
"""
|
||||
if 'entry_1/instrument_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('instrument_1')
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'source_1' not in i1:
|
||||
i1.create_group('source_1')
|
||||
s1 = i1['source_1']
|
||||
s1['wavelength'] = np.float32(wavelength)
|
||||
s1['energy'] = np.float32(1.9864459e-25 / wavelength)
|
||||
|
||||
|
||||
|
||||
def add_detector(cxi_file, distance, basis, corner=None):
|
||||
"""Adds the entry_1/instrument_1/detector_1 group to a cxi file object
|
||||
|
||||
It will define all the relevant parameters - distance, pixel size,
|
||||
detector basis, and corner position (if relevant) based on the provided
|
||||
information.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the detector to
|
||||
distance : float
|
||||
The sample to detector distance
|
||||
basis : array
|
||||
The detector basis
|
||||
corner : array
|
||||
Optional, the corner position of the detector
|
||||
|
||||
"""
|
||||
if 'entry_1/instrument_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('instrument_1')
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'detector_1' not in i1:
|
||||
i1.create_group('detector_1')
|
||||
d1 = i1['detector_1']
|
||||
|
||||
d1['distance'] = np.float32(distance)
|
||||
|
||||
if isinstance(basis, t.Tensor):
|
||||
basis = basis.detach().cpu().numpy()
|
||||
if basis.shape == (2,3):
|
||||
basis = basis.T
|
||||
d1['x_pixel_size'] = np.linalg.norm(basis[:,1])
|
||||
d1['y_pixel_size'] = np.linalg.norm(basis[:,0])
|
||||
d1.create_dataset('basis_vectors', data=basis)
|
||||
|
||||
if corner is not None:
|
||||
if isinstance(corner, t.Tensor):
|
||||
corner = corner.detach().cpu().numpy()
|
||||
d1.create_dataset('corner_position',data=corner)
|
||||
|
||||
|
||||
def add_mask(cxi_file, mask):
|
||||
"""Adds the specified mask to the cxi file
|
||||
|
||||
It places the mask into the mask dataset under
|
||||
entry_1/instrument_1/detector_1. The internal mask is defined
|
||||
simply as a 1 for an "on" pixel and a 0 for an "off" pixel, and
|
||||
the saved mask is exactly the opposite. This is simpler than the
|
||||
most general mask allowed by the cxi file format but it captures the
|
||||
distinction between pixels to be used and pixels not to be used.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the mask to
|
||||
mask : array
|
||||
The mask to save out to the file
|
||||
"""
|
||||
|
||||
if 'entry_1/instrument_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('instrument_1')
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'detector_1' not in i1:
|
||||
i1.create_group('detector_1')
|
||||
d1 = i1['detector_1']
|
||||
if isinstance(mask, t.Tensor):
|
||||
mask = mask.detach().cpu().numpy()
|
||||
|
||||
mask_to_save = np.zeros(mask.shape).astype(np.uint32)
|
||||
mask_to_save[mask == 0] = 1
|
||||
d1.create_dataset('mask',data=mask_to_save)
|
||||
|
||||
|
||||
def add_dark(cxi_file, dark):
|
||||
"""Adds the specified dark image to a cxi file
|
||||
|
||||
It places the dark image data into the data_dark dataset under
|
||||
entry_1/instrument_1/detector_1.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the mask to
|
||||
dark : array
|
||||
The dark image(s) to save out to the file
|
||||
"""
|
||||
if 'entry_1/instrument_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('instrument_1')
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'detector_1' not in i1:
|
||||
i1.create_group('detector_1')
|
||||
d1 = i1['detector_1']
|
||||
if isinstance(dark, t.Tensor):
|
||||
dark = dark.detach().cpu().numpy()
|
||||
|
||||
d1.create_dataset('data_dark',data=dark)
|
||||
|
||||
|
||||
def add_data(cxi_file, data, axes=None, compression='gzip',
|
||||
chunks=True):
|
||||
"""Adds the specified data to the cxi file
|
||||
|
||||
It will add the data unchanged to the file, placing it in two spots:
|
||||
|
||||
1) The entry_1/instrument_1/detector_1/data path
|
||||
2) A softlink at entry_1/data_1/data
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the data to
|
||||
data : array
|
||||
The data to be saved
|
||||
axes : list(str)
|
||||
Optional, a list of axis names to be saved in the axes attribute
|
||||
"""
|
||||
if 'entry_1/data_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('data_1')
|
||||
data1 = cxi_file['entry_1/data_1']
|
||||
|
||||
if 'entry_1/instrument_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('instrument_1')
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'detector_1' not in i1:
|
||||
i1.create_group('detector_1')
|
||||
det1 = i1['detector_1']
|
||||
|
||||
if isinstance(data, t.Tensor):
|
||||
data = data.detach().cpu().numpy()
|
||||
|
||||
det1.create_dataset('data', data=data, compression=compression,
|
||||
chunks=chunks)
|
||||
data1['data'] = h5py.SoftLink('/entry_1/instrument_1/detector_1/data')
|
||||
|
||||
if axes is not None:
|
||||
if isinstance(axes, list):
|
||||
axes_str = ':'.join(axes)
|
||||
else:
|
||||
axes_str = str(axes)
|
||||
det1['data'].attrs['axes'] = np.string_(axes_str)
|
||||
|
||||
|
||||
def add_shot_to_shot_info(cxi_file, data, field_name):
|
||||
"""Adds a specified dataset of shot-to-shot information to the cxi file
|
||||
|
||||
The data is assumed to be in the form of an array, with one dimension
|
||||
being the number of patterns being stored in the dataset. This is
|
||||
helpful for storing additional readback data on the shot-to-shot
|
||||
level that may be important but doens't have a clearly defined
|
||||
place to be stored in the .cxi file specification. Such data includes
|
||||
shot-to-shot probe intensity measurements, polarizer positions, etc.
|
||||
|
||||
This function is also used internally to store the translations
|
||||
associated with a ptychography experiment
|
||||
|
||||
It will store this data in 3 places:
|
||||
|
||||
1) The entry_1/sample_1/geometry_1/<field_name> path
|
||||
2) A softlink at entry_1/data_1/<field_name>
|
||||
3) A softlink at entry_1/instrument_1/detector_1/<field_name>
|
||||
|
||||
The geometry and detector paths may not always be relevant, but this
|
||||
ensures that the data is always available in any of the places that
|
||||
an eventual reader may go to look for, e.g., the translations.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the translations to
|
||||
data : array
|
||||
The data to be saved
|
||||
field_name : str
|
||||
The field name to save the data under
|
||||
"""
|
||||
|
||||
if 'entry_1/sample_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('sample_1')
|
||||
s1 = cxi_file['entry_1/sample_1']
|
||||
|
||||
if 'geometry_1' not in s1:
|
||||
s1.create_group('geometry_1')
|
||||
g1 = s1['geometry_1']
|
||||
|
||||
if 'entry_1/data_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('data_1')
|
||||
data1 = cxi_file['entry_1/data_1']
|
||||
|
||||
if 'entry_1/instrument_1' not in cxi_file:
|
||||
cxi_file['entry_1'].create_group('instrument_1')
|
||||
i1 = cxi_file['entry_1/instrument_1']
|
||||
if 'detector_1' not in i1:
|
||||
i1.create_group('detector_1')
|
||||
det1 = i1['detector_1']
|
||||
|
||||
|
||||
if isinstance(data, t.Tensor):
|
||||
data = data.detach().cpu().numpy()
|
||||
|
||||
|
||||
g1.create_dataset(field_name, data=data)
|
||||
data1[field_name] = h5py.SoftLink('/entry_1/sample_1/geometry_1/'
|
||||
+ field_name)
|
||||
det1[field_name] = h5py.SoftLink('/entry_1/sample_1/geometry_1/'
|
||||
+ field_name)
|
||||
|
||||
|
||||
def add_ptycho_translations(cxi_file, translations):
|
||||
"""Adds the specified translations to the cxi file
|
||||
|
||||
It will add the translations to the file, negating them to conform to
|
||||
the standard in cxi files that the translations refer to the object's
|
||||
translation.
|
||||
|
||||
It will store them in 3 places:
|
||||
|
||||
1) The entry_1/sample_1/geometry_1/translation path
|
||||
2) A softlink at entry_1/data_1/translation
|
||||
3) A softlink at entry_1/instrument_1/detector_1/translation
|
||||
|
||||
Parameters
|
||||
----------
|
||||
cxi_file : h5py.File
|
||||
The file to add the translations to
|
||||
translations : array
|
||||
The translations to be saved
|
||||
"""
|
||||
# accounting for the different definition between cxi files and
|
||||
# CDTools
|
||||
translations = -translations
|
||||
|
||||
add_shot_to_shot_info(cxi_file, translations, 'translation')
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.image_processing.image_processing import *
|
||||
@@ -0,0 +1,319 @@
|
||||
"""Contains functions for basic image processing needs
|
||||
|
||||
This module contains two kinds of image processing tools. The first type
|
||||
is specific tools for calculating commonly needed metrics (such as the
|
||||
centroid of an image), directly on complex-valued torch tensors. The second
|
||||
kind of tools perform common image manipulations on torch tensors, in such
|
||||
a way that it is safe to include them in automatic differentiation models.
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
import torch as t
|
||||
from CDTools.tools import propagators
|
||||
|
||||
__all__ = ['centroid', 'centroid_sq', 'sinc_subpixel_shift',
|
||||
'find_subpixel_shift', 'find_pixel_shift', 'find_shift',
|
||||
'convolve_1d', 'fourier_upsample']
|
||||
|
||||
|
||||
def centroid(im, dims=2):
|
||||
"""Returns the centroid of an image or a stack of images
|
||||
|
||||
By default, the last two dimensions are used in the calculation
|
||||
and the remainder of the dimensions are passed through.
|
||||
|
||||
Beware that the meaning of the centroid is not well defined if your
|
||||
image contains values less than 0
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : torch.Tensor
|
||||
An image or stack of images to calculate from
|
||||
dims : int
|
||||
Default 2, how many trailing dimensions to calculate with
|
||||
|
||||
Returns
|
||||
-------
|
||||
centroid : torch.Tensor
|
||||
An (i,j) index or stack of indices
|
||||
"""
|
||||
# For some reason this needs to be a list
|
||||
indices = [t.arange(im.shape[-dims+i]).to(t.float32) for i in range(dims)]
|
||||
indices = t.meshgrid(*indices, indexing='ij')
|
||||
|
||||
use_dims = [-dims+i for i in range(dims)]
|
||||
divisor = t.sum(im, dim=use_dims)
|
||||
centroids = [t.sum(index * im, dim=use_dims) / divisor
|
||||
for index in indices]
|
||||
|
||||
return t.stack(centroids,dim=-1)
|
||||
|
||||
|
||||
def centroid_sq(im, dims=2, comp=False):
|
||||
"""Returns the centroid of the square of an image or stack of images
|
||||
|
||||
By default, the last two dimensions are used in the calculation
|
||||
and the remainder of the dimensions are passed through.
|
||||
|
||||
If the "comp" flag is set, it will be assumed that the last dimension
|
||||
represents the real and imaginary part of a complex number, and the
|
||||
centroid will be calculated for the magnitude squared of those numbers
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : torch.Tensor
|
||||
An image or stack of images to calculate from
|
||||
dims : int
|
||||
Default 2, how many trailing dimensions to calculate for
|
||||
comp : bool
|
||||
Default is False, whether the data represents complex numbers
|
||||
|
||||
Returns
|
||||
-------
|
||||
centroid: torch.Tensor
|
||||
An (i,j) index or stack of indices
|
||||
"""
|
||||
if comp:
|
||||
im_sq = t.abs(im)**2
|
||||
else:
|
||||
im_sq = im**2
|
||||
|
||||
return centroid(im_sq, dims=dims)
|
||||
|
||||
|
||||
def sinc_subpixel_shift(im, shift):
|
||||
"""Performs a subpixel shift with sinc interpolation on the given tensor
|
||||
|
||||
The subpixel shift is done circularly via a multiplication with a linear
|
||||
phase mask in Fourier space.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : torch.Tensor
|
||||
A complex-valued tensor to perform the subpixel shift on
|
||||
shift : array
|
||||
A length-2 array describing the shift to perform, in pixels
|
||||
|
||||
Returns
|
||||
-------
|
||||
shifted_im : torch.Tensor
|
||||
The subpixel shifted tensor
|
||||
"""
|
||||
|
||||
i = t.arange(im.shape[0]) - im.shape[0]//2
|
||||
j = t.arange(im.shape[1]) - im.shape[1]//2
|
||||
I,J = t.meshgrid(i,j, indexing='ij')
|
||||
I = 2 * np.pi * I.to(t.float32) / im.shape[0]
|
||||
J = 2 * np.pi * J.to(t.float32) / im.shape[1]
|
||||
I = I.to(dtype=im.dtype,device=im.device)
|
||||
J = J.to(dtype=im.dtype,device=im.device)
|
||||
|
||||
fft_im = t.fft.fftshift(t.fft.fft2(im),dim=(-2,-1))
|
||||
shifted_fft_im = fft_im * t.exp(1j * (-shift[0]*I - shift[1]*J))
|
||||
return t.fft.ifft2(t.fft.ifftshift(shifted_fft_im, dim=(-2,-1)))
|
||||
|
||||
|
||||
|
||||
def find_subpixel_shift(im1, im2, search_around=(0,0), resolution=10):
|
||||
"""Calculates the subpixel shift between two images by maximizing the autocorrelation
|
||||
|
||||
This function only searches in a 2 pixel by 2 pixel box around the
|
||||
specified search_around parameter. The calculation is done using the
|
||||
approach outlined in "Efficient subpixel image registration algorithms",
|
||||
Optics Express (2008) by Manual Guizar-Sicarios et al.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im1 : torch.Tensor
|
||||
The first real or complex-valued torch tensor
|
||||
im2 : torch.Tensor
|
||||
The second real or complex-valued torch tensor
|
||||
search_around : array
|
||||
Default (0,0), the shift to search in the vicinity of
|
||||
resolution : int
|
||||
Default is 10, the fraction of a pixel to calculate to
|
||||
|
||||
Returns
|
||||
-------
|
||||
shift : torch.Tensor
|
||||
The relative shift (i,j) needed to best map im1 onto im2
|
||||
"""
|
||||
|
||||
#
|
||||
# Here's my approach, perhaps it's a little unconventional. I will first
|
||||
# calculate the phase correlation function as found in ____ (cite a paper
|
||||
# defining it). This is strongly peaked, so I can take a small window
|
||||
# of say, 10x10 pixels, and then do a sinc interpolation of that area
|
||||
# using an FFT with upsampling by a factor of resolution in reciprocal
|
||||
# space
|
||||
#
|
||||
cor_fft = t.fft.fft2(im1) * t.conj(t.fft.fft2(im2))
|
||||
|
||||
# Not sure if this is more or less stable than just the correlation
|
||||
# maximum - requires some testing
|
||||
cor = t.fft.ifft2(cor_fft / t.abs(cor_fft))
|
||||
|
||||
|
||||
# Now, I need to shift the array to pull out a contiguous window
|
||||
# around the correlation maximum
|
||||
try:
|
||||
search_around = search_around.cpu()
|
||||
except:
|
||||
search_around = t.as_tensor(search_around)
|
||||
|
||||
window_size = 15
|
||||
shift_zero = tuple(-search_around + t.tensor([window_size,window_size]))
|
||||
cor_window = t.roll(cor, shift_zero, dims=(-2,-1))[...,:2*window_size,:2*window_size]
|
||||
|
||||
# Now we upsample this window
|
||||
cor_window_fft = t.fft.fftshift(t.fft.fft2(cor_window),dim=(-2,-1))
|
||||
upsampled = t.zeros(tuple(t.tensor(cor_window_fft.shape) * resolution),
|
||||
dtype=cor.dtype,device=cor.device)
|
||||
|
||||
upsampled[...,:2*window_size,:2*window_size] = cor_window_fft
|
||||
upsampled = t.roll(upsampled,(-window_size,-window_size),dims=(0,1))
|
||||
upsampled = t.roll(t.abs(t.fft.ifft2(upsampled))**2,
|
||||
(-window_size*resolution,-window_size*resolution),
|
||||
dims=(0,1))
|
||||
|
||||
|
||||
# And we extract the shift from the window
|
||||
sh = t.as_tensor(upsampled.shape, device=upsampled.device)
|
||||
cormax = t.as_tensor([t.div(t.argmax(upsampled), sh[1],
|
||||
rounding_mode='floor'),
|
||||
t.argmax(upsampled) % sh[1]],
|
||||
device=upsampled.device)
|
||||
|
||||
sh_over_2 = t.div(sh,2,rounding_mode='floor')
|
||||
subpixel_shift = ((cormax + sh_over_2) % sh - sh_over_2).to(dtype=upsampled.dtype)
|
||||
|
||||
return search_around.to(device=upsampled.device, dtype=upsampled.dtype) + \
|
||||
subpixel_shift / resolution
|
||||
|
||||
|
||||
def find_pixel_shift(im1, im2):
|
||||
"""Calculates the integer pixel shift between two images by maximizing the autocorrelation
|
||||
|
||||
This function simply takes the circular correlation with an FFT and
|
||||
returns the position of the maximum of that correlation. This corresponds
|
||||
to the amount that im1 would have to be shifted by to line up best with
|
||||
im2
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im1 : torch.Tensor
|
||||
The first real or complex-valued torch tensor
|
||||
im2 : torch.Tensor
|
||||
The second real or complex-valued torch tensor
|
||||
|
||||
Returns
|
||||
-------
|
||||
shift : torch.Tensor
|
||||
The integer-valued shift (i,j) that best maps im1 onto im2
|
||||
"""
|
||||
cor_fft = t.fft.fft2(im1) * t.conj(t.fft.fft2(im2))
|
||||
|
||||
# Not sure if this is more or less stable than just the correlation
|
||||
# maximum - requires some testing
|
||||
cor = t.abs(t.fft.ifft2(cor_fft / t.abs(cor_fft)))
|
||||
|
||||
|
||||
sh = t.as_tensor(cor.shape,device=im1.device)
|
||||
cormax = t.tensor([t.div(t.argmax(cor),sh[1],rounding_mode='floor'),
|
||||
t.argmax(cor) % sh[1]]).to(device=im1.device)
|
||||
|
||||
sh_over_2 = t.div(sh,2,rounding_mode='floor')
|
||||
return (cormax + sh_over_2) % sh - sh_over_2
|
||||
|
||||
|
||||
|
||||
def find_shift(im1, im2, resolution=10):
|
||||
"""Calculates the shift between two images by maximizing the autocorrelation
|
||||
|
||||
This function starts by calculating the maximum shift to integer
|
||||
pixel resolution, and then searchers the nearby area to calculate a
|
||||
subpixel shift
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im1 : torch.Tensor
|
||||
The first real or complex-valued torch tensor
|
||||
im2 : torch.Tensor
|
||||
The second real or complex-valued torch tensor
|
||||
resolution : int
|
||||
Default is 10, the fraction of a pixel to calculate to
|
||||
|
||||
Returns
|
||||
-------
|
||||
shift : torch.Tensor
|
||||
The relative shift (i,j) needed to best map im1 onto im2
|
||||
"""
|
||||
integer_shift = find_pixel_shift(im1,im2)
|
||||
subpixel_shift = find_subpixel_shift(im1, im2, search_around=integer_shift,
|
||||
resolution=resolution)
|
||||
|
||||
return subpixel_shift
|
||||
|
||||
|
||||
def convolve_1d(image, kernel, dim=0, fftshift_kernel=True):
|
||||
"""Convolves an image with a 1d kernel along a specified dimension
|
||||
|
||||
The convolution is a circular convolution calculated using a Fourier
|
||||
transform. The calculation is done so the input remains differentiable
|
||||
with respect to the output.
|
||||
|
||||
If the image has a final dimension of 2, it is assumed to be complex.
|
||||
Otherwise, the image is assumed to be real. The image and kernel
|
||||
must either both be real or both be complex.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
image : torch.Tensor
|
||||
The image to convolve
|
||||
kernel : torch.Tensor
|
||||
The 1d kernel to convolve with
|
||||
dim : int
|
||||
Default 0, the dimension to convolve along
|
||||
fftshift_kernel : bool
|
||||
Default True, whether to fftshift the kernel first.
|
||||
|
||||
Returns
|
||||
-------
|
||||
convolved_im : torch.Tensor
|
||||
The convolved image
|
||||
"""
|
||||
|
||||
|
||||
if fftshift_kernel:
|
||||
kernel = t.fft.ifftshift(kernel,dim=(-1,))
|
||||
|
||||
# We have to transpose the relevant dimension to -1 before using the fft,
|
||||
# which expects to operate on the final dimension
|
||||
trans_im = t.transpose(image, dim, -1)
|
||||
|
||||
# Take a correlation
|
||||
fft_im = t.fft.fft(trans_im)
|
||||
fft_kernel = t.fft.fft(kernel)
|
||||
trans_conv = t.fft.ifft(fft_im * fft_kernel)
|
||||
|
||||
conv_im = t.transpose(trans_conv, dim, -1)
|
||||
|
||||
return conv_im
|
||||
|
||||
|
||||
def fourier_upsample(ims, preserve_mean=False):
|
||||
# If preserve_mean is true, it preserves the mean pixel intensity
|
||||
# otherwise, it preserves the total summed intensity
|
||||
upsampled = t.zeros(ims.shape[:-2]+(2*ims.shape[-2],2*ims.shape[-1]),
|
||||
dtype=ims.dtype,
|
||||
device=ims.device)
|
||||
left = [ims.shape[-2]//2,ims.shape[-1]//2]
|
||||
right = [ims.shape[-2]//2+ims.shape[-2],
|
||||
ims.shape[-1]//2+ims.shape[-1]]
|
||||
|
||||
upsampled[...,left[0]:right[0],left[1]:right[1]] = propagators.far_field(ims)
|
||||
if preserve_mean:
|
||||
upsampled *= 2
|
||||
return propagators.inverse_far_field(upsampled)
|
||||
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.initializers.initializers import *
|
||||
@@ -0,0 +1,659 @@
|
||||
"""Contains functions to sensibly initialize reconstructions
|
||||
|
||||
The functions in this module both do the geometric calculations needed to
|
||||
initialize the reconstrucions, and the heuristic calculations for
|
||||
geierating sensible initializations for the probe guess.
|
||||
"""
|
||||
|
||||
import math
|
||||
import numpy as np
|
||||
import torch as t
|
||||
from CDTools.tools.propagators import *
|
||||
from CDTools.tools.analysis import orthogonalize_probes
|
||||
from CDTools.tools import image_processing
|
||||
from scipy.fftpack import next_fast_len
|
||||
from scipy.sparse import linalg as spla
|
||||
from torch.nn.functional import pad
|
||||
import numpy as np
|
||||
from functools import *
|
||||
|
||||
__all__ = ['exit_wave_geometry', 'calc_object_setup', 'gaussian',
|
||||
'gaussian_probe', 'SHARP_style_probe', 'STEM_style_probe',
|
||||
'RPI_spectral_init',
|
||||
'generate_subdominant_modes']
|
||||
|
||||
def exit_wave_geometry(det_basis, det_shape, wavelength, distance, center=None, opt_for_fft=True, padding=0, oversampling=1):
|
||||
"""Returns an exit wave basis and shape, as well as a detector slice for the given detector geometry
|
||||
|
||||
It takes in the parameters for a given detector - the basis defining
|
||||
the pixel pitch and the shape, as well as the wavelength and propagation
|
||||
distance. Optionally, it accepts a defined "center", the zero-frequency
|
||||
pixel's location. It then will automatically define a larger detector
|
||||
if necessary, define the exit wave basis associated with a far-field
|
||||
diffraction experiment, and return that basis, shape, and detector slice
|
||||
|
||||
Parameters
|
||||
----------
|
||||
det_basis : torch.Tensor
|
||||
The detector basis, as defined elsewhere
|
||||
det_shape : torch.Size
|
||||
The (i,j) shape of the detector
|
||||
wavelength : float)
|
||||
The wavelength of light for the experiment, in m
|
||||
distance : float
|
||||
The sample-detector distance, in m
|
||||
center : torch.Tensor
|
||||
If defined, the location of the zero frequency pixel
|
||||
opt_for_fft : bool
|
||||
Default is true, whether to increase detector size to improve fft performance
|
||||
padding : int
|
||||
Default is 0, the size of an extra border of nonphysical pixels around the detector
|
||||
oversampling : int
|
||||
Default is 1, the amount to multiply the exit wave shape by.
|
||||
|
||||
Returns
|
||||
-------
|
||||
basis : torch.Tensor
|
||||
The exit wave basis
|
||||
shape : torch.Tensor
|
||||
The exit wave's shape
|
||||
slice : slice
|
||||
The slice corresponding to the physical detector
|
||||
"""
|
||||
|
||||
det_shape = t.as_tensor(tuple(det_shape), dtype=t.int32)
|
||||
det_basis = t.as_tensor(det_basis)
|
||||
# First, set the center if it's not already specified
|
||||
# This definition matches the center pixel of an fftshifted array
|
||||
if center is None:
|
||||
# this is center//2, but in pytorch 1.9.0 it throws a warning
|
||||
# if you just do that
|
||||
|
||||
center = t.div(det_shape,2,rounding_mode='floor')# // 2
|
||||
else:
|
||||
center = t.as_tensor(center, dtype=t.int32)
|
||||
|
||||
# Then, calculate the required detector size from the centering
|
||||
# This is a bit opaque but was worth doing accurately
|
||||
min_left = center * 2
|
||||
min_right = (det_shape - center) * 2 - 1
|
||||
full_shape = t.max(min_left,min_right).to(t.int32) + 2 * padding
|
||||
|
||||
# In some edge cases this shape can be smaller than the detector shape
|
||||
full_shape = t.max(full_shape, det_shape)
|
||||
|
||||
|
||||
if opt_for_fft:
|
||||
full_shape = t.as_tensor([next_fast_len(dim) for dim in full_shape],
|
||||
dtype=t.int32)
|
||||
|
||||
# Then, generate a slice that pops the actual detector from the full
|
||||
# detector shape
|
||||
# this is full_center//2, but in pytorch 1.9.0 it throws a warning
|
||||
# if you just do that
|
||||
full_center = t.div(full_shape,2, rounding_mode='floor')# // 2
|
||||
det_slice = np.s_[int(full_center[0]-center[0]):
|
||||
int(full_center[0]-center[0]+det_shape[0]),
|
||||
int(full_center[1]-center[1]):
|
||||
int(full_center[1]-center[1]+det_shape[1])]
|
||||
|
||||
|
||||
# Finally, generate the basis for the exit wave in real space
|
||||
|
||||
# This method should work for a general parallelogram
|
||||
# shaped detector
|
||||
det_shape = det_basis * full_shape.to(t.float32)
|
||||
pinv_basis = t.tensor(np.linalg.pinv(det_shape).transpose()).to(t.float32)
|
||||
real_space_basis = pinv_basis * wavelength * distance
|
||||
|
||||
# This is definitely correct, but less simple. Included here
|
||||
# So future me can check that both versions are consistent.
|
||||
#oop_dir = np.cross(det_basis[:,0],det_basis[:,1])
|
||||
#oop_dir /= np.linalg.norm(oop_dir)
|
||||
#full_basis = np.array([np.array(det_basis[:,0]),np.array(det_basis[:,1]),oop_dir]).transpose()
|
||||
#inv_basis = t.tensor(np.linalg.inv(full_basis)[:2,:].transpose()).to(t.float32)
|
||||
#real_space_basis = inv_basis*wavelength * distance / \
|
||||
# full_shape.to(t.float32)
|
||||
|
||||
# Finally, convert the shape back to a torch.Size
|
||||
full_shape = t.Size([dim * oversampling for dim in full_shape])
|
||||
|
||||
|
||||
return real_space_basis, full_shape, det_slice
|
||||
|
||||
|
||||
def calc_object_setup(probe_shape, translations, padding=0):
|
||||
"""Returns an object shape and minimum pixel translation
|
||||
|
||||
Based on the given pixel-space translations, it will calculate the
|
||||
required size for an object array and calculate the pixel translation
|
||||
that corresponds to a shift by (0,0) of the probe.
|
||||
|
||||
Optionally a small extra border can be defined via the padding
|
||||
attribute. If this is done, the calculated pixel translation will
|
||||
correspond to (padding,padding)
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probe_shape : torch.Size
|
||||
The size of the probe array
|
||||
translations : torch.Tensor
|
||||
A Jx2 stack of pixel-valued (i,j) translations
|
||||
padding : int
|
||||
Optional, the size of an extra border to include
|
||||
|
||||
Returns
|
||||
-------
|
||||
obj_shape : torch.Size
|
||||
The minimum required size of the object array
|
||||
min_translation : torch.Tensor
|
||||
The minimum pixel-valued translation
|
||||
"""
|
||||
|
||||
# First we look at the translations to find the minimum translation
|
||||
# and the range of translations
|
||||
min_translation = t.min(translations, dim=0)[0]
|
||||
translation_range = t.max(translations, dim=0)[0] - min_translation
|
||||
|
||||
# Calculate the required shape
|
||||
translation_range = t.ceil(translation_range).numpy().astype(np.int32)
|
||||
shape = translation_range + np.array(probe_shape) + 2 * padding
|
||||
shape = t.Size(shape)
|
||||
|
||||
# And the minimum translation
|
||||
min_translation = min_translation - padding
|
||||
|
||||
return shape, min_translation
|
||||
|
||||
|
||||
|
||||
def gaussian(shape, sigma, amplitude=1, center = None, curvature=[0,0]):
|
||||
"""Returns an array with a centered Gaussian
|
||||
|
||||
Takes in the shape and standard deviation of a gaussian
|
||||
and returns a complex torch tensor (trailing dimension is 2) with
|
||||
values corresponding to a two-dimensional gaussian function
|
||||
|
||||
Note that [0, 0] is taken to be at the upper left corner of the array.
|
||||
Default is centered at ((shape[0]-1)/2, (shape[1]-1)/2)) because x and y are zero-indexed.
|
||||
By default, the phase is uniformly 0, however a curvature can be
|
||||
specified to simulate a probe that has been propagated a known distance
|
||||
from it's focal point. The curvature is implemented by adding a quadratic
|
||||
phase phi = exp(i*curvature/2 r^2) to the Gaussian
|
||||
|
||||
Parameters
|
||||
----------
|
||||
shape : array
|
||||
A 1x2 array specifying the dimensions of the output array in the form (i shape, j shape)
|
||||
sigma : array
|
||||
A 1x2 array specifying the i- and j- standard deviation of the gaussian in the form (i stdev, j stdev)
|
||||
amplitude : float
|
||||
Default 1, the amplitude the gaussian to simulate
|
||||
center : array
|
||||
Optional, a 1x2 array specifying the location of the center of the gaussian (i center, j center)
|
||||
curvature : array
|
||||
Optional, a complex part to add to the gaussian coefficient
|
||||
|
||||
Returns
|
||||
-------
|
||||
torch.Tensor
|
||||
The complex-style tensor storing the Gaussian
|
||||
"""
|
||||
if center is None:
|
||||
center = ((shape[0]-1)/2, (shape[1]-1)/2)
|
||||
|
||||
i, j = np.mgrid[:shape[0], :shape[1]]
|
||||
isq = (i - center[0])**2
|
||||
jsq = (j - center[1])**2
|
||||
result = np.exp((1j*curvature[0] / 2 - 1 / (2 * sigma[0]**2)) * isq + \
|
||||
(1j*curvature[1] / 2 - 1 / (2 * sigma[1]**2)) * jsq)
|
||||
return t.as_tensor(amplitude*result,dtype=t.complex64)
|
||||
|
||||
|
||||
|
||||
def gaussian_probe(dataset, basis, shape, sigma, propagation_distance=0, polarized=False, left_polarized=True):
|
||||
"""Initializes a gaussian probe based on experimental parameters
|
||||
|
||||
This function generates a gaussian probe initialization which has a
|
||||
total fluence matching the order of magnitude of the intensity in
|
||||
the observed dataset, provided the object function is of order 1.
|
||||
|
||||
The initialization is done using parameters defined in physical units,
|
||||
such as sigma (in meters) and the propagation distance (in meters).
|
||||
The internal conversion to pixel space is done with a provided probe
|
||||
basis and probe shape.
|
||||
|
||||
TODO: Should be updated to accept a mask
|
||||
|
||||
Sigma can be provided either as a scalar for a uniform beam, or as
|
||||
an iterable of length 2 with [sigma_i, sigma_j] being the components
|
||||
of sigma in the directions parallel to the i and j basis vectors of
|
||||
the probe basis
|
||||
|
||||
Parameters
|
||||
----------
|
||||
dataset : Ptycho_2D_Dataset
|
||||
The dataset whose intensity we want to match
|
||||
basis : array
|
||||
The real space basis for exit waves in our experiment
|
||||
shape : array
|
||||
The shape of the simulated real space arrays
|
||||
sigma : array
|
||||
The standard deviation of the probe at it's focus
|
||||
propagation_distance : float
|
||||
Default 0, a distance to propagate the gaussian from it's focus
|
||||
|
||||
Returns
|
||||
-------
|
||||
torch.Tensor
|
||||
The complex-style tensor storing the Gaussian
|
||||
"""
|
||||
# First, we want to generate the parameters (sigma and curvature) for the
|
||||
# propagated gaussian. Ignore the purely z-dependent phases
|
||||
wavelength = dataset.wavelength
|
||||
if propagation_distance is None:
|
||||
propagation_distance = 0
|
||||
|
||||
z = propagation_distance # for shorthand
|
||||
|
||||
sigma = np.array(sigma)
|
||||
k = 2 * np.pi / wavelength
|
||||
zr = k * sigma**2
|
||||
sigmaz = sigma * np.sqrt(1 + (z / zr)**2)
|
||||
curvature = -k * z / (z**2 + zr**2)
|
||||
|
||||
# The conversion must then be done to pixel space
|
||||
sigma_pix = sigmaz / np.array([np.linalg.norm(basis[:,0]),
|
||||
np.linalg.norm(basis[:,1])])
|
||||
curvature_pix = curvature * np.array([np.linalg.norm(basis[:,0]),
|
||||
np.linalg.norm(basis[:,1])])**2
|
||||
|
||||
# Then we can generate the gaussian array
|
||||
probe = gaussian(shape, sigma=sigma_pix, curvature=curvature_pix)
|
||||
|
||||
# Finally, we should calculate the average pattern intensity from the
|
||||
# dataset and normalize the gaussian probe. This should be done by
|
||||
if not polarized:
|
||||
avg_intensities = [t.sum(dataset[idx][1]) for idx in range(len(dataset))]
|
||||
|
||||
else:
|
||||
polarizer = dataset.polarizer.tolist()
|
||||
analyzer = dataset.analyzer.tolist()
|
||||
factors = [(math.cos(math.radians(polarizer[idx] - analyzer[idx])))**2 for idx in range(len(dataset)) if (abs(polarizer[idx] - analyzer[idx]) > 5)]
|
||||
avg_intensities = [t.sum(dataset[idx][1]) / factor[idx] for idx in range(len(dataset))]
|
||||
|
||||
avg_intensity = t.mean(t.tensor(avg_intensities))
|
||||
probe_intensity = t.sum(t.abs(probe)**2)
|
||||
probe = t.sqrt(avg_intensity / probe_intensity) * probe
|
||||
|
||||
if polarized:
|
||||
if left_polarized == True:
|
||||
x = 1j
|
||||
else:
|
||||
x = -1j
|
||||
probe = t.stack((probe.to(dtype=t.cfloat), x * probe.to(dtype=t.cfloat)), dim=-4)
|
||||
return probe[..., None, :, :]
|
||||
|
||||
return probe
|
||||
|
||||
|
||||
|
||||
|
||||
def SHARP_style_probe(dataset, shape, det_slice, propagation_distance=None, oversampling=1, polarized=False, left_polarized=True):
|
||||
"""Generates a SHARP style probe guess from a dataset
|
||||
|
||||
What we call the "SHARP" style probe guess is to take a mean of all
|
||||
the diffraction patterns and use that as an initial guess of the
|
||||
Fourier space distribution of the probe. We set all the phases to
|
||||
zero, which would for many simple beams (like a zone plate) generate
|
||||
a first guess of the probe that is very close to the focal spot of
|
||||
the probe beam.
|
||||
|
||||
If the probe is simulated in higher resolution than the detector,
|
||||
a common occurence, these undefined pixels are set to zero for the
|
||||
purposes of defining the guess
|
||||
|
||||
We make a small tweak to this procedure to lower the central pixel of
|
||||
the probe generated this way, which can often overwhelm the rest of the
|
||||
probe if there is significant noise on the detector
|
||||
|
||||
Parameters
|
||||
----------
|
||||
dataset : Ptycho_2D_Dataset
|
||||
The dataset to work from
|
||||
shape : torch.Size
|
||||
The size of the probe array to simulate
|
||||
det_slice : slice
|
||||
A slice or tuple of slices corresponding to the detector region in Fourier space
|
||||
propagation_distance : float
|
||||
Default is no propagation, an amount to propagate the guessed probe from it's focal point
|
||||
oversampling : int
|
||||
Default 1, the width of the region of pixels in the wavefield to bin into a single detector pixel
|
||||
|
||||
Returns
|
||||
-------
|
||||
torch.Tensor
|
||||
The complex-style tensor storing the probe guess
|
||||
"""
|
||||
|
||||
# NOTE: I don't love the way np and torch are mixed here, I think this
|
||||
# function deserves some love.
|
||||
|
||||
# to use the mask or not?
|
||||
intensities = np.zeros([dim // oversampling for dim in shape])
|
||||
|
||||
if polarized:
|
||||
factors = [(math.cos(math.radians(polarizer[idx] - analyzer[idx])))**2 for idx in range(len(dataset)) if abs(polarizer[idx] - analyzer[idx]) > 5]
|
||||
else:
|
||||
factors = [1 for idx in range(len(dataset))]
|
||||
|
||||
|
||||
for params, im in dataset:
|
||||
if hasattr(dataset,'mask') and dataset.mask is not None:
|
||||
intensities[det_slice] += dataset.mask.cpu().numpy() * im.cpu().numpy() / factors[params[0]]
|
||||
else:
|
||||
intensities[det_slice] += im.cpu().numpy() / params[factors[0]]
|
||||
intensities /= len(dataset)
|
||||
|
||||
|
||||
|
||||
# Subtract off a known background if it's stored
|
||||
if hasattr(dataset, 'background') and dataset.background is not None:
|
||||
intensities[det_slice] = np.clip(intensities[det_slice] - dataset.background.cpu().numpy(), a_min=0,a_max=None)
|
||||
|
||||
probe_fft = t.tensor(np.sqrt(intensities)).to(dtype=t.complex64)
|
||||
|
||||
probe_guess = inverse_far_field(probe_fft).numpy()
|
||||
# Now we remove the central pixel
|
||||
#center = np.array(probe_guess.shape) // 2
|
||||
|
||||
# I'm always unsure whether to use this modification:
|
||||
|
||||
#probe_guess[center[0], center[1]]=np.mean([
|
||||
# probe_guess[center[0]-1, center[1]],
|
||||
# probe_guess[center[0]+1, center[1]],
|
||||
# probe_guess[center[0], center[1]-1],
|
||||
# probe_guess[center[0], center[1]+1]])
|
||||
|
||||
probe_guess = t.as_tensor(probe_guess, dtype=t.complex64)
|
||||
|
||||
if propagation_distance is not None:
|
||||
# First generate the propagation array
|
||||
|
||||
probe_shape = t.as_tensor(tuple(probe_guess.shape))
|
||||
|
||||
# Start by recalculating the probe basis from the given information
|
||||
det_basis = t.as_tensor(dataset.detector_geometry['basis'])
|
||||
basis_dirs = det_basis / t.norm(det_basis, dim=0)
|
||||
distance = dataset.detector_geometry['distance']
|
||||
probe_basis = basis_dirs * dataset.wavelength * distance / \
|
||||
(probe_shape * t.norm(det_basis,dim=0))
|
||||
|
||||
# Then package everything as it's needed
|
||||
probe_spacing = t.norm(probe_basis,dim=0).numpy()
|
||||
probe_shape = probe_shape.numpy().astype(np.int32)
|
||||
|
||||
# And generate the propagator
|
||||
AS_prop = generate_angular_spectrum_propagator(probe_shape, probe_spacing, dataset.wavelength, propagation_distance)
|
||||
|
||||
probe_guess = near_field(probe_guess,AS_prop)
|
||||
|
||||
# Finally, place this probe in a full-sized array if there is oversampling
|
||||
final_probe = t.zeros(shape,dtype=t.complex64)
|
||||
left = shape[0]//2 - probe_guess.shape[0] // 2
|
||||
top = shape[1]//2 - probe_guess.shape[1] // 2
|
||||
final_probe[left:left+probe_guess.shape[0],
|
||||
top:top+probe_guess.shape[1]] = probe_guess
|
||||
|
||||
if polarized:
|
||||
if left_polarized:
|
||||
x = 1j
|
||||
else:
|
||||
x = -1j
|
||||
final_probe = t.stack((final_probe.to(dtype=t.cfloat), final_probe.to(dtype=t.cfloat)), dim=-4)
|
||||
final_probe = final_probe[..., None, :, :]
|
||||
|
||||
return final_probe
|
||||
|
||||
|
||||
def STEM_style_probe(dataset, shape, det_slice, convergence_semiangle, propagation_distance=None, oversampling=1):
|
||||
"""Generates a STEM style probe guess from a dataset
|
||||
|
||||
What we call the "STEM" style probe guess is a probe generated by
|
||||
a uniform aperture in Fourier space, with no optical aberrations.
|
||||
This is the kind of probe than an ideal, aberration-corrected STEM
|
||||
with perfect coherence would produce, so it is a good starting
|
||||
guess for STEM datasets.
|
||||
|
||||
We set the initial intensity of the probe with relation to the
|
||||
diffraction patterns so that a typical object will have an intensity
|
||||
of around 1. We also set the initial phase ramp of the probe such that
|
||||
the undiffracted probe has a centroid on the detector which matches the
|
||||
centroid of the diffraction patterns
|
||||
|
||||
Parameters
|
||||
----------
|
||||
dataset : Ptycho_2D_Dataset
|
||||
The dataset to work from
|
||||
shape : torch.Size
|
||||
The size of the probe array to simulate
|
||||
det_slice : slice
|
||||
A slice or tuple of slices corresponding to the detector region in Fourier space
|
||||
convergence_angle : float
|
||||
The convergence angle of the probe, in mrad.
|
||||
propagation_distance : float
|
||||
Default is no propagation, an amount to propagate the guessed probe from it's focal point
|
||||
oversampling : int
|
||||
Default 1, the width of the region of pixels in the wavefield to bin into a single detector pixel
|
||||
|
||||
Returns
|
||||
-------
|
||||
torch.Tensor
|
||||
The complex-style tensor storing the probe guess
|
||||
"""
|
||||
|
||||
# The basis in the dataset should describe the basis of the probe's
|
||||
# Fourier transform, even if the probe is simulated on larger stage than
|
||||
# the detector. The only issue is if the probe is oversampled in
|
||||
# Fourier space (simulated on a larger stage in real space). That factor
|
||||
# is defined by oversampling.
|
||||
|
||||
probe_basis = (t.as_tensor(dataset.detector_geometry['basis'],
|
||||
dtype=t.float32)
|
||||
/ oversampling)
|
||||
|
||||
mean_im = t.mean(dataset.patterns,dim=0)
|
||||
center = image_processing.centroid(mean_im)
|
||||
|
||||
Is = t.arange(shape[0], dtype=t.float32) - center[0]
|
||||
Js = t.arange(shape[1], dtype=t.float32) - center[1]
|
||||
Is,Js = t.meshgrid(Is,Js)
|
||||
|
||||
Rs = t.tensordot(probe_basis,t.stack([Is,Js]),dims=1)
|
||||
forward = t.Tensor([0,0,1])
|
||||
Rs = (forward * dataset.detector_geometry['distance'])[:,None,None] + Rs
|
||||
dirs = Rs / t.linalg.norm(Rs,dim=(0,))
|
||||
angles = t.acos(t.tensordot(forward,dirs,dims=1)) * 1000 #in mrad
|
||||
|
||||
probe_fft = t.zeros(shape,dtype=t.complex64)
|
||||
probe_fft[angles<convergence_semiangle] = 1
|
||||
|
||||
probe_mean = t.mean(t.abs(probe_fft)**2)
|
||||
diff_mean = t.mean(mean_im)
|
||||
probe_fft = probe_fft * t.sqrt(diff_mean / probe_mean)
|
||||
|
||||
probe_guess = inverse_far_field(probe_fft)
|
||||
|
||||
if propagation_distance is not None:
|
||||
# It's probably worth checking if this is correct when oversampling
|
||||
# is not 1
|
||||
|
||||
probe_shape = t.as_tensor(tuple(probe_guess.shape))
|
||||
|
||||
# Start by recalculating the probe basis from the given information
|
||||
det_basis = t.as_tensor(dataset.detector_geometry['basis'])
|
||||
basis_dirs = det_basis / t.norm(det_basis, dim=0)
|
||||
distance = dataset.detector_geometry['distance']
|
||||
probe_basis = basis_dirs * dataset.wavelength * distance / \
|
||||
(probe_shape * t.norm(det_basis,dim=0))
|
||||
|
||||
# Then package everything as it's needed
|
||||
probe_spacing = t.norm(probe_basis,dim=0).numpy()
|
||||
probe_shape = probe_shape.numpy().astype(np.int32)
|
||||
|
||||
# And generate the propagator
|
||||
AS_prop = generate_angular_spectrum_propagator(probe_shape, probe_spacing, dataset.wavelength, propagation_distance)
|
||||
|
||||
probe_guess = near_field(probe_guess,AS_prop)
|
||||
|
||||
# Finally, place this probe in a full-sized array if there is oversampling
|
||||
final_probe = t.zeros(shape,dtype=t.complex64)
|
||||
left = shape[0]//2 - probe_guess.shape[0] // 2
|
||||
top = shape[1]//2 - probe_guess.shape[1] // 2
|
||||
final_probe[left:left+probe_guess.shape[0],
|
||||
top:top+probe_guess.shape[1]] = probe_guess
|
||||
|
||||
return final_probe
|
||||
|
||||
|
||||
def RPI_spectral_init(pattern, probe, obj_shape, n_modes=1, mask=None, background=None):
|
||||
|
||||
# First, check if the probe is a single mode or many modes.
|
||||
# If the probe is many modes, orthogonalize it and use the top mode
|
||||
# for initialization
|
||||
if probe.dim() == 4:
|
||||
probe = orthogonalize_probes(probe)[0]
|
||||
|
||||
pad0l = (probe.shape[-2] - obj_shape[0])//2
|
||||
pad0r = probe.shape[-2] - obj_shape[0] - pad0l
|
||||
pad1l = (probe.shape[-1] - obj_shape[1])//2
|
||||
pad1r = probe.shape[-1] - obj_shape[1] - pad1l
|
||||
|
||||
def a_dagger(im):
|
||||
im = t.tensor(im.reshape(obj_shape)).to(dtype=t.complex64)
|
||||
im = inverse_far_field(pad(far_field(im), (pad1l,pad1r,pad0l,pad0r)))
|
||||
exit_wave = probe * im
|
||||
return far_field(exit_wave).numpy().ravel()
|
||||
|
||||
def a(measured):
|
||||
measured = t.tensor(measured.reshape(pattern.shape[0],pattern.shape[1])).to(dtype=t.complex64)
|
||||
im = inverse_far_field(measured)
|
||||
multiplied = t.conj(probe) * im
|
||||
backplane = far_field(multiplied)
|
||||
clipped = backplane[pad0l:pad0l+obj_shape[0],
|
||||
pad1l:pad1l+obj_shape[1]]
|
||||
return (inverse_far_field(clipped)).numpy().ravel()
|
||||
|
||||
patsize = pattern.shape[0]*pattern.shape[1]
|
||||
imsize = obj_shape[0]*obj_shape[1]
|
||||
probesize = probe.shape[0]*probe.shape[1]
|
||||
A_dagger = spla.LinearOperator((patsize, imsize),matvec=a_dagger)
|
||||
A = spla.LinearOperator((imsize,patsize),matvec=a)
|
||||
|
||||
# Correct the pattern for the background and mask
|
||||
np_pattern = pattern.numpy()
|
||||
if background is not None:
|
||||
np_pattern = np_pattern - background.numpy()
|
||||
if mask is not None:
|
||||
np_pattern = np_pattern * mask.numpy()
|
||||
np_pattern = np.abs(np_pattern.ravel())
|
||||
|
||||
realspace_intensities = A * A_dagger * np.ones(imsize)
|
||||
vec = A_dagger * realspace_intensities
|
||||
def y(measured):
|
||||
#return measured * np_pattern
|
||||
# This normalizes the intensities to account for the fact
|
||||
# that some pixels draw from way more spots on the detector than
|
||||
# others
|
||||
return measured * np_pattern / np.abs(vec)
|
||||
|
||||
Y = spla.LinearOperator((patsize, patsize),matvec=y)
|
||||
eigval, z0 = spla.eigs(A * Y * A_dagger, k=n_modes, which='LM')
|
||||
z0 = z0.transpose().reshape(n_modes,obj_shape[0], obj_shape[1])
|
||||
|
||||
# Now we set the overall scale and relative weights of the guess
|
||||
scale_factor = np.sqrt(np.sum(np_pattern) /
|
||||
t.sum(t.abs(probe)**2).numpy())
|
||||
relative_weights = eigval / np.sum(eigval**2)
|
||||
|
||||
z0 = z0 * (scale_factor * relative_weights[:,None,None])
|
||||
# Now we have to normalize the modes by their eigenvalues
|
||||
|
||||
return t.as_tensor(z0, dtype=t.complex64)
|
||||
|
||||
|
||||
def generate_subdominant_modes(dominant_mode, n_modes, circular=True):
|
||||
"""Generates guesses of subdominant modes based on spatial derivatives
|
||||
|
||||
The idea here is that vibration is an extremely common cause of
|
||||
spatial incoherence. This typically presents as subdominant modes that
|
||||
look like the derivative of the dominant mode along various axes.
|
||||
|
||||
Therefore, it is a good starting guess if the guess of the dominant
|
||||
mode is reasonable. The output probes will all be normalized to have
|
||||
the same intensity as the input dominant probe
|
||||
|
||||
Parameters
|
||||
----------
|
||||
dominant_mode : array
|
||||
The complex-valued dominant mode to work from
|
||||
n_modes : int
|
||||
The number of additional modes to create
|
||||
circular : bool
|
||||
Default True, whether to use circular modes (x+iy) or linear (x,y)
|
||||
Returns
|
||||
-------
|
||||
torch.Tensor
|
||||
The complex-style tensor storing the probe guesses
|
||||
"""
|
||||
|
||||
# This generates a list of tuples, where each tuple (a,b) corresponds
|
||||
# a term (kx^a)*(ky^b), or (kx+iky)^a*(kx-iky)^b for circular modes
|
||||
def make_orders(n_orders):
|
||||
if n_orders >1024:
|
||||
raise KeyError('Are you sure you want this many orders?')
|
||||
i = 1
|
||||
n = 0
|
||||
total = 0
|
||||
while True:
|
||||
if total >= n_orders:
|
||||
break
|
||||
|
||||
yield (n,i-n)
|
||||
total += 1
|
||||
if n<i:
|
||||
n+=1
|
||||
else:
|
||||
n = 0
|
||||
i += 1
|
||||
|
||||
# Gotta check and convert to pytorch if it's numpy
|
||||
|
||||
# First step is to take the FFT of the probe
|
||||
dominant_fft = far_field(dominant_mode)
|
||||
|
||||
shape = dominant_mode.shape
|
||||
center = ((shape[-2])//2, (shape[-1])//2)
|
||||
|
||||
i, j = np.mgrid[:shape[-2], :shape[-1]]
|
||||
i = t.tensor(i - center[0]).to(dtype=dominant_fft.dtype,
|
||||
device=dominant_fft.device)
|
||||
j = t.tensor(j - center[1]).to(dtype=dominant_fft.dtype,
|
||||
device=dominant_fft.device)
|
||||
|
||||
if circular:
|
||||
a = i + 1j * j
|
||||
b = i - 1j * j
|
||||
else:
|
||||
a = i
|
||||
b = j
|
||||
|
||||
probe_norm = t.sum(t.abs(dominant_mode)**2)
|
||||
# Then we need to multiply that FFT by various phase masks and IFFT
|
||||
probes = []
|
||||
for a_order,b_order in make_orders(n_modes):
|
||||
mask = reduce(t.mul,[a]*a_order+[b]*b_order)
|
||||
new_probe = inverse_far_field(mask * dominant_fft)
|
||||
probes.append(new_probe * (probe_norm / t.sum(t.abs(new_probe))))
|
||||
|
||||
return t.stack(probes)
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.interactions.interactions import *
|
||||
@@ -0,0 +1,633 @@
|
||||
""" This module contains various to simulate stages in the probe-sample interaction
|
||||
|
||||
All the tools here are designed to work with automatic differentiation. Each
|
||||
function simulates some aspect of an interaction model that can be used
|
||||
for ptychographic reconstruction.
|
||||
"""
|
||||
|
||||
import torch as t
|
||||
import numpy as np
|
||||
from CDTools.tools import propagators, image_processing, polarization
|
||||
|
||||
__all__ = ['translations_to_pixel', 'pixel_to_translations',
|
||||
'project_translations_to_sample',
|
||||
'ptycho_2D_round','ptycho_2D_linear','ptycho_2D_sinc',
|
||||
'RPI_interaction']
|
||||
|
||||
|
||||
def translations_to_pixel(basis, translations, surface_normal=t.Tensor([0.,0.,1.])):
|
||||
"""Takes real space translations and outputs them in pixel space
|
||||
|
||||
This works for any 2D ptychography geometry. It takes in
|
||||
A set of translations in (x,y) space and outputs the same translations
|
||||
in internal pixel units perpendicular to the detector.
|
||||
|
||||
It uses information on the wavefield basis and, if defined, the
|
||||
sample normal, to perform the conversion.
|
||||
|
||||
The assumed geometry is incoming radiation with a wavevector parallel
|
||||
to the +z axis, [0,0,1]. The default sample orientation has a surface
|
||||
normal parallel to this direction
|
||||
|
||||
Parameters
|
||||
----------
|
||||
basis : torch.Tensor
|
||||
The real space basis the wavefields are defined in
|
||||
translations : torch.Tensor
|
||||
A Jx3 stack of real-space translations, or a single translation
|
||||
surface_normal : torch.Tensor
|
||||
Optional, the sample's surface normal
|
||||
|
||||
Returns
|
||||
-------
|
||||
pixel_translations : torch.Tensor
|
||||
A Jx2 stack of translations in internal (i,j) pixel-space, or a single translation
|
||||
"""
|
||||
|
||||
projection_1 = t.Tensor([[1,0,0],
|
||||
[0,1,0],
|
||||
[0,0,0]]).to(device=translations.device,dtype=translations.dtype)
|
||||
projection_2 = t.inverse(t.Tensor([[1,0,0],
|
||||
[0,1,0],
|
||||
-surface_normal/
|
||||
surface_normal[2]])).to(device=translations.device,dtype=translations.dtype)
|
||||
basis_vectors_inv = t.pinverse(basis).to(device=translations.device,
|
||||
dtype=translations.dtype)
|
||||
projection = t.mm(basis_vectors_inv,
|
||||
t.mm(projection_2,projection_1))
|
||||
projection = projection.t()
|
||||
|
||||
single_translation = False
|
||||
if len(translations.shape) == 1:
|
||||
translations = translations[None,:]
|
||||
single_translation = True
|
||||
|
||||
pixel_translations = t.mm(translations, projection)
|
||||
|
||||
if single_translation:
|
||||
return pixel_translations[0]
|
||||
else:
|
||||
return pixel_translations
|
||||
|
||||
|
||||
def pixel_to_translations(basis, pixel_translations, surface_normal=t.Tensor([0,0,1])):
|
||||
"""Takes pixel-space translations and outputs them in real space
|
||||
|
||||
This works for any 2D ptychography geometry. It takes in
|
||||
A set of internal pixel unit translations in (i,j) space and
|
||||
outputs the same translations real (x,y) space
|
||||
|
||||
It uses information on the wavefield basis and, if defined, the
|
||||
sample normal, to perform the conversion.
|
||||
|
||||
The assumed geometry is incoming radiation with a wavevector parallel
|
||||
to the +z axis, [0,0,1]. The default sample orientation has a surface
|
||||
normal parallel to this direction. Because of this, the z direction
|
||||
translation is always set to zero in the conversion
|
||||
|
||||
Parameters
|
||||
----------
|
||||
basis : torch.Tensor
|
||||
The real space basis the wavefields are defined in
|
||||
translations : torch.Tensor
|
||||
A Jx2 stack of pixel-space translations, or a single translation
|
||||
surface_normal : torch.Tensor
|
||||
Optional, the sample's surface normal
|
||||
|
||||
Returns
|
||||
-------
|
||||
real_translations : torch.Tensor
|
||||
A Jx3 stack of real-space translations, or a single translation
|
||||
"""
|
||||
projection_1 = t.Tensor([[1,0,0],
|
||||
[0,1,0],
|
||||
[0,0,0]]).to(device=basis.device,dtype=basis.dtype)
|
||||
projection_2 = t.inverse(t.Tensor([[1,0,0],
|
||||
[0,1,0],
|
||||
-surface_normal/
|
||||
surface_normal[2]])).to(device=basis.device,dtype=basis.dtype)
|
||||
basis_vectors_inv = t.pinverse(basis)
|
||||
projection = t.mm(basis_vectors_inv,
|
||||
t.mm(projection_2,projection_1))
|
||||
# Literally just need the pseudoinverse of the projection we used to go
|
||||
# the other way
|
||||
projection = t.pinverse(projection).t()
|
||||
|
||||
single_translation = False
|
||||
if len(pixel_translations.shape) == 1:
|
||||
pixel_translations = pixel_translations[None,:]
|
||||
single_translation = True
|
||||
|
||||
translations = t.mm(pixel_translations, projection)
|
||||
|
||||
if single_translation:
|
||||
return translations[0]
|
||||
else:
|
||||
return translations
|
||||
|
||||
|
||||
|
||||
def project_translations_to_sample(sample_basis, translations):
|
||||
"""Takes real space translations and outputs them in pixels in a sample basis
|
||||
|
||||
This projection function is designed for the Bragg2DPtycho class. More
|
||||
broadly, it works to take a set of translations in the lab frame and
|
||||
convert each one into two values. First, an (i,j) value in pixels
|
||||
describing the location of the probe's intersection with the sample
|
||||
plane, assuming the basis found in sample_basis is used. Second, an
|
||||
amount that the probe must be propagated along the z-axis to reach
|
||||
the sample plane at the given location. This includes both the effect of
|
||||
the tilted sample plane and any explicitly defined motion along the z axis
|
||||
of the probe-forming optic as included in the input translations.
|
||||
|
||||
|
||||
Note that because of the sign convention (that this function returns th
|
||||
relative amount the probe needs to be propagated to reach any given
|
||||
location), a positive motion along the z-axis of the probe forming optics
|
||||
will lead to a negative propagation distance.
|
||||
|
||||
The assumed geometry is incoming radiation with a wavevector parallel
|
||||
to the +z axis, [0,0,1].
|
||||
|
||||
Parameters
|
||||
----------
|
||||
sample_basis : torch.Tensor
|
||||
The real space basis the wavefields are defined in
|
||||
translations : torch.Tensor
|
||||
A Jx3 stack of real-space translations, or a single translation
|
||||
|
||||
Returns
|
||||
-------
|
||||
pixel_translations : torch.Tensor
|
||||
A Jx2 stack of translations in internal (i,j) pixel-space, or a single translation
|
||||
propagations : torch.Tensor
|
||||
A length-J vector of propagation distances, in meters
|
||||
"""
|
||||
|
||||
# Must do this all in pytorch unfortunately
|
||||
# First we calculate the surface normal for the projection onto the sample
|
||||
surface_normal = t.cross(sample_basis[:,1],sample_basis[:,0])
|
||||
surface_normal /= t.norm(surface_normal)
|
||||
|
||||
|
||||
# Then we calculate a matrix which can do the projection
|
||||
|
||||
propagation_dir = t.Tensor(np.array([0,0,1])).to(
|
||||
device=surface_normal.device,
|
||||
dtype=surface_normal.dtype)
|
||||
|
||||
I = t.eye(3).to(
|
||||
device=surface_normal.device,
|
||||
dtype=surface_normal.dtype)
|
||||
|
||||
# Here we're setting up a matrix-vector equation mat*answer=input
|
||||
# At some point ger will need to be replaced by outer, but for now
|
||||
# outer many places still don't have new enough versions of torch.
|
||||
mat = t.cat((I - t.ger(propagation_dir,propagation_dir),
|
||||
surface_normal.unsqueeze(0)))
|
||||
|
||||
# And we invert the matrix to do the projection
|
||||
projector = t.pinverse(mat)[:,:3].to(device=translations.device,
|
||||
dtype=translations.dtype)
|
||||
|
||||
# Finally, we need to get the result in the right basis, so this will
|
||||
# do that conversion for us
|
||||
basis_vectors_inv = t.pinverse(sample_basis).to(device=translations.device,
|
||||
dtype=translations.dtype)
|
||||
|
||||
# Same for the propagation direction to extract how far it must propagate
|
||||
propagation_dir_inv = propagation_dir.unsqueeze(0).to(
|
||||
device=translations.device,
|
||||
dtype=translations.dtype)
|
||||
|
||||
|
||||
sample_projection = t.mm(basis_vectors_inv, projector).t()
|
||||
prop_projection = t.mm(propagation_dir_inv, projector).t()
|
||||
|
||||
|
||||
single_translation = False
|
||||
if len(translations.shape) == 1:
|
||||
translations = translations[None,:]
|
||||
single_translation = True
|
||||
|
||||
pixel_translations = t.mm(translations, sample_projection)
|
||||
propagations = t.mm(translations, prop_projection) \
|
||||
- t.mm(translations,propagation_dir[:,None])
|
||||
|
||||
if single_translation:
|
||||
return pixel_translations[0], propagations[0]
|
||||
else:
|
||||
return pixel_translations, propagations
|
||||
|
||||
|
||||
|
||||
|
||||
def ptycho_2D_round(probe, obj, translations, multiple_modes=False, upsample_obj=False):
|
||||
"""Returns a stack of exit waves without accounting for subpixel shifts
|
||||
|
||||
This function returns a collection of exit waves, with the first
|
||||
dimension as the translation index and the final dimensions
|
||||
corresponding to the detector. The exit waves are calculated by
|
||||
shifting the probe by the rounded value of the translation
|
||||
|
||||
If multiple_modes is set to False, any additional dimensions in the
|
||||
ptycho_2D_round function will be assumed to correspond to the translation
|
||||
index. If multiple_modes is set to true, the (-4th) dimension of the probe
|
||||
will always be assumed to be defining a set of (P) incoherently mixing
|
||||
modes to be broadcast all translation indices. If any additional dimensions
|
||||
closer to the start exist, they will be assumed to be translation indices
|
||||
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probe : torch.Tensor
|
||||
A (P)xMxL probe function to illuminate the object
|
||||
object : torch.Tensor
|
||||
The object function to be probed
|
||||
translations : torch.Tensor
|
||||
The (N)x2 array of (i,j) translations to simulate
|
||||
multuple_modes : bool
|
||||
Default False, whether to assume the probe contains multiple modes
|
||||
|
||||
Returns
|
||||
-------
|
||||
exit_waves : torch.Tensor
|
||||
An (N)x(P)xMxL tensor of the calculated exit waves
|
||||
"""
|
||||
|
||||
single_translation = False
|
||||
if translations.dim() == 1:
|
||||
translations = translations[None,:]
|
||||
single_translation = True
|
||||
|
||||
|
||||
integer_translations = t.round(translations).to(dtype=t.int32)
|
||||
|
||||
if upsample_obj:
|
||||
selections = t.stack([obj[tr[0]:tr[0]+probe.shape[-2]//2,
|
||||
tr[1]:tr[1]+probe.shape[-1]//2]
|
||||
for tr in integer_translations])
|
||||
selections = image_processing.fourier_upsample(selections,
|
||||
preserve_mean=True)
|
||||
|
||||
else:
|
||||
selections = t.stack([obj[tr[0]:tr[0]+probe.shape[-2],
|
||||
tr[1]:tr[1]+probe.shape[-1]]
|
||||
for tr in integer_translations])
|
||||
|
||||
|
||||
if multiple_modes:
|
||||
# if the probe dimension is 4, then this hasn't yet been broadcast
|
||||
# over the translation dimensions
|
||||
output = probe * selections[:,None,:,:]
|
||||
else:
|
||||
output = probe * selections
|
||||
|
||||
if single_translation:
|
||||
return output[0]
|
||||
else:
|
||||
return output
|
||||
|
||||
|
||||
|
||||
def ptycho_2D_linear(probe, obj, translations, shift_probe=True):
|
||||
"""Returns a stack of exit waves accounting for subpixel shifts
|
||||
|
||||
This function returns a collection of exit waves, with the first
|
||||
dimension as the translation index and the final dimensions
|
||||
corresponding to the detector. The exit waves are calculated by
|
||||
shifting the probe with each translation in turn, using linear
|
||||
interpolation to combine the results
|
||||
|
||||
If shift_probe is True, it applies the subpixel shift to the probe,
|
||||
otherwise the subpixel shift is applied to the object
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probe : torch.Tensor
|
||||
An MxL probe function for the exit waves
|
||||
object : torch.Tensor
|
||||
The object function to be probed
|
||||
translations : torch.Tensor
|
||||
The Nx2 array of translations to simulate
|
||||
shift_probe : bool
|
||||
Default True, Whether to subpixel shift the probe or object
|
||||
|
||||
Returns
|
||||
-------
|
||||
exit_waves : torch.Tensor
|
||||
An NxMxL tensor of the calculated exit waves
|
||||
"""
|
||||
single_translation = False
|
||||
if translations.dim() == 1:
|
||||
translations = translations[None,:]
|
||||
single_translation = True
|
||||
|
||||
# Separate the translations into a part that chooses the window
|
||||
# And a part that defines the windowing function
|
||||
integer_translations = t.floor(translations)
|
||||
subpixel_translations = translations - integer_translations
|
||||
integer_translations = integer_translations.to(dtype=t.int32)
|
||||
|
||||
exit_waves = []
|
||||
if shift_probe:
|
||||
for tr, sp in zip(integer_translations,
|
||||
subpixel_translations):
|
||||
# This isn't perfectly symmetric but I think it's okay for now
|
||||
# It should get the job done
|
||||
# Basically, we shift the probe's position by a subpixel (i,j),
|
||||
# rolling the edges of the array, and use that to multiply
|
||||
# by the object
|
||||
sel00 = probe[:,:]
|
||||
sel01 = t.cat((probe[:,-1:],probe[:,:-1]),dim=1)
|
||||
sel10 = t.cat((probe[-1:,:],probe[:-1,:]),dim=0)
|
||||
sel11 = t.cat((sel01[-1:,:],sel01[:-1,:]),dim=0)
|
||||
|
||||
selection = sel00 * (1-sp[0])*(1-sp[1]) + \
|
||||
sel10 * sp[0]*(1-sp[1]) + \
|
||||
sel01 * (1-sp[0])*sp[1] + \
|
||||
sel11 * sp[0]*sp[1]
|
||||
|
||||
obj_slice = obj[tr[0]:tr[0]+probe.shape[0],
|
||||
tr[1]:tr[1]+probe.shape[1]]
|
||||
|
||||
exit_waves.append(selection * obj_slice)
|
||||
else:
|
||||
for tr, sp in zip(integer_translations,
|
||||
subpixel_translations):
|
||||
#
|
||||
# Here we subpixel shift the object by (-i,-j) after
|
||||
# slicing out the correct translation of the probe
|
||||
#
|
||||
|
||||
sel00 = obj[tr[0]:tr[0]+probe.shape[0],
|
||||
tr[1]:tr[1]+probe.shape[1]]
|
||||
|
||||
sel01 = obj[tr[0]:tr[0]+probe.shape[0],
|
||||
tr[1]+1:tr[1]+1+probe.shape[1]]
|
||||
|
||||
sel10 = obj[tr[0]+1:tr[0]+1+probe.shape[0],
|
||||
tr[1]:tr[1]+probe.shape[1]]
|
||||
|
||||
sel11 = obj[tr[0]+1:tr[0]+1+probe.shape[0],
|
||||
tr[1]+1:tr[1]+1+probe.shape[1]]
|
||||
|
||||
selection = sel00 * (1-sp[0])*(1-sp[1]) + \
|
||||
sel01 * (1-sp[0])*sp[1] + \
|
||||
sel10 * sp[0]*(1-sp[1]) + \
|
||||
sel11 * sp[0]*sp[1]
|
||||
|
||||
exit_waves.append(probe * selection)
|
||||
|
||||
if single_translation:
|
||||
return exit_waves[0]
|
||||
else:
|
||||
return t.stack(exit_waves)
|
||||
|
||||
|
||||
def ptycho_2D_sinc(probe, obj, translations, shift_probe=True, padding=10, multiple_modes=True, polarized=False, polarizer=None, analyzer=None):
|
||||
"""Returns a stack of exit waves accounting for subpixel shifts
|
||||
|
||||
This function returns a collection of exit waves, with the first
|
||||
dimension as the translation index and the final dimensions
|
||||
corresponding to the detector. The exit waves are calculated by
|
||||
shifting the probe with each translation in turn, using sinc
|
||||
interpolation (done via multiplication with a complex exponential
|
||||
in Fourier space)
|
||||
|
||||
If shift_probe is True, it applies the subpixel shift to the probe,
|
||||
otherwise the subpixel shift is applied to the object [not yet implemented]
|
||||
|
||||
If multiple_modes is set to False, any additional dimensions in the
|
||||
ptycho_2D_round function will be assumed to correspond to the translation
|
||||
index. If multiple_modes is set to true, the (-4th) dimension of the probe
|
||||
will always be assumed to be defining a set of (P) incoherently mixing
|
||||
modes to be broadcast all translation indices. If any additional dimensions
|
||||
closer to the start exist, they will be assumed to be translation indices
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probe : torch.Tensor
|
||||
An (P)xMxL probe function for the exit waves
|
||||
object : torch.Tensor
|
||||
The object function to be probed
|
||||
translations : torch.Tensor
|
||||
The (N)x2 array of translations to simulate
|
||||
shift_probe : bool
|
||||
Default True, Whether to subpixel shift the probe or object
|
||||
multuple_modes : bool
|
||||
Default False, whether to assume the probe contains multiple modes
|
||||
|
||||
Returns
|
||||
-------
|
||||
exit_waves : torch.Tensor
|
||||
An (N)x(P)xMxL tensor of the calculated exit waves
|
||||
"""
|
||||
|
||||
single_translation = False
|
||||
if translations.dim() == 1:
|
||||
translations = translations[None, :]
|
||||
single_translation = True
|
||||
|
||||
# Separate the translations into a part that chooses the window
|
||||
# And a part that defines the windowing function
|
||||
integer_translations = t.floor(translations)
|
||||
subpixel_translations = translations - integer_translations
|
||||
integer_translations = integer_translations.to(dtype=t.int32)
|
||||
if not polarized:
|
||||
selections = t.stack([obj[tr[0]:tr[0]+probe.shape[-2],
|
||||
tr[1]:tr[1]+probe.shape[-1]]
|
||||
for tr in integer_translations])
|
||||
else:
|
||||
selections = t.stack([obj[:, :, tr[0]:tr[0]+probe.shape[-2],
|
||||
tr[1]:tr[1]+probe.shape[-1]]
|
||||
for tr in integer_translations])
|
||||
# Nx2x2xMxL tensor
|
||||
|
||||
exit_waves = []
|
||||
if shift_probe:
|
||||
i = t.arange(probe.shape[-2],device=probe.device,dtype=t.float32) \
|
||||
- probe.shape[-2]//2
|
||||
j = t.arange(probe.shape[-1],device=probe.device,dtype=t.float32) \
|
||||
- probe.shape[-1]//2
|
||||
I,J = t.meshgrid(i,j, indexing='ij')
|
||||
I = 2 * np.pi * I / probe.shape[-2]
|
||||
J = 2 * np.pi * J / probe.shape[-1]
|
||||
phase_masks = t.exp(1j*(-subpixel_translations[:,0,None,None]*I
|
||||
-subpixel_translations[:,1,None,None]*J))
|
||||
if polarized:
|
||||
phase_masks = phase_masks[..., None, :, :]
|
||||
# Nx2x1xMxL tensor
|
||||
# probe is (N)(P)x2xMxL tensor
|
||||
fft_probe = t.fft.fftshift(t.fft.fft2(probe),dim=(-1,-2))
|
||||
if multiple_modes: # Multi-mode probe
|
||||
if polarized:
|
||||
shifted_fft_probe = fft_probe * phase_masks[...,None,:,:,:]
|
||||
else:
|
||||
shifted_fft_probe = fft_probe * phase_masks[...,None,:,:]
|
||||
else:
|
||||
shifted_fft_probe = fft_probe * phase_masks
|
||||
shifted_probe = t.fft.ifft2(t.fft.ifftshift(shifted_fft_probe,
|
||||
dim=(-1,-2)))
|
||||
if not polarized:
|
||||
if multiple_modes: # Multi-mode probe
|
||||
output = shifted_probe * selections[...,None,:,:]
|
||||
else:
|
||||
output = shifted_probe * selections
|
||||
# selections: Nx2x2xMxL
|
||||
# probe: Nx(P)x2x1xMxL
|
||||
else:
|
||||
output = polarization.apply_jones_matrix(shifted_probe, selections, multiple_modes=multiple_modes)
|
||||
|
||||
else:
|
||||
raise NotImplementedError('Object shift not yet implemented')
|
||||
if single_translation:
|
||||
return output[0]
|
||||
else:
|
||||
return output
|
||||
|
||||
|
||||
def ptycho_2D_sinc_s_matrix(probe, s_matrix, translations, shift_probe=True, padding=10):
|
||||
"""Returns a stack of exit waves accounting for subpixel shifts
|
||||
|
||||
This function returns a collection of exit waves, with the first
|
||||
dimension as the translation index and the final dimensions
|
||||
corresponding to the detector. The exit waves are calculated by
|
||||
shifting the probe with each translation in turn, using sinc
|
||||
interpolation (done via multiplication with a complex exponential
|
||||
in Fourier space)
|
||||
|
||||
If shift_probe is True, it applies the subpixel shift to the probe,
|
||||
otherwise the subpixel shift is applied to the object
|
||||
|
||||
This needs to be edited to use a slightly different meaning of the s-wave
|
||||
format. Currently, each pixel in the latter two dimensions index a location
|
||||
on the input wavefield, and the first two indexes index differences from
|
||||
that pixel. It is easier to interpret the resulting matrix though if the
|
||||
latter two indices index locations in the output plane. NOTE: I believe
|
||||
this change has now been made
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probe : torch.Tensor
|
||||
An MxL probe function for the exit waves
|
||||
s_matrix : torch.Tensor
|
||||
The 4D S-Matrix tensor (2B+1x2B+1xObject Shape) to be probed
|
||||
translations : torch.Tensor
|
||||
The Nx2 array of translations to simulate
|
||||
shift_probe : bool
|
||||
Default True, Whether to subpixel shift the probe or object
|
||||
padding : int
|
||||
Default 10, if shifting the object, the padding to apply to the object to avoid circular shift effects
|
||||
|
||||
Returns
|
||||
-------
|
||||
exit_waves : torch.Tensor
|
||||
An NxMxL tensor of the calculated exit waves
|
||||
"""
|
||||
single_translation = False
|
||||
if translations.dim() == 1:
|
||||
translations = translations[None,:]
|
||||
single_translation = True
|
||||
|
||||
# Separate the translations into a part that chooses the window
|
||||
# And a part that defines the windowing function
|
||||
integer_translations = t.floor(translations)
|
||||
subpixel_translations = translations - integer_translations
|
||||
integer_translations = integer_translations.to(dtype=t.int32)
|
||||
|
||||
exit_waves = []
|
||||
|
||||
B = s_matrix.shape[0]//2
|
||||
|
||||
if shift_probe:
|
||||
i = t.arange(probe.shape[-2]) - probe.shape[-2]//2
|
||||
j = t.arange(probe.shape[-1]) - probe.shape[-1]//2
|
||||
I,J = t.meshgrid(i,j, indexing='ij')
|
||||
I = 2 * np.pi * I.to(t.float32) / probe.shape[-2]
|
||||
J = 2 * np.pi * J.to(t.float32) / probe.shape[-1]
|
||||
I = I.to(dtype=probe.dtype,device=probe.device)
|
||||
J = J.to(dtype=probe.dtype,device=probe.device)
|
||||
|
||||
for tr, sp in zip(integer_translations,
|
||||
subpixel_translations):
|
||||
fft_probe = t.fft.fftshift(t.fft.fft2(probe), dim=(-1,-2))
|
||||
shifted_fft_probe = fft_probe * t.exp(1j*(-sp[0]*I - sp[1]*J))
|
||||
shifted_probe = t.fft.ifft2(t.fft.ifftshift(shifted_fft_probe,
|
||||
dim=(-1,-2)))
|
||||
|
||||
s_matrix_slice = s_matrix[:,:,tr[0]:tr[0]+probe.shape[-2]+2*B,
|
||||
tr[1]:tr[1]+probe.shape[-1]+2*B]
|
||||
|
||||
|
||||
output = t.zeros([probe.shape[-2]+2*B,probe.shape[-1]+2*B,2]).to(
|
||||
device=s_matrix_slice.device,
|
||||
dtype=s_matrix_slice.dtype)
|
||||
|
||||
|
||||
for i in range(s_matrix.shape[0]):
|
||||
for j in range(s_matrix.shape[1]):
|
||||
output [i:i+probe.shape[-2],j:j+probe.shape[-1]] += \
|
||||
shifted_probe * s_matrix_slice[i,j,i:i+probe.shape[-2],j:j+probe.shape[-1]]
|
||||
|
||||
exit_waves.append(output)
|
||||
|
||||
else:
|
||||
raise NotImplementedError('Object shift not yet implemented')
|
||||
|
||||
if single_translation:
|
||||
return exit_waves[0]
|
||||
else:
|
||||
return t.stack(exit_waves)
|
||||
|
||||
|
||||
def RPI_interaction(probe, obj):
|
||||
"""Returns an exit wave from a high-res probe and a low-res obj
|
||||
|
||||
In this interaction, the probe and object arrays are assumed to cover
|
||||
the same physical region of space, but with the probe array sampling that
|
||||
region of space more finely. Thus, to do the interaction, the object
|
||||
is first upsampled by padding it in Fourier space (equivalent to a sinc
|
||||
interpolation) before being multiplied with the probe. This function is
|
||||
called RPI_interaction because this interaction is central to the RPI
|
||||
method and is not commonly used elsewhere.
|
||||
|
||||
This also works with object functions that have an extra first dimension
|
||||
for an incoherently mixing model.
|
||||
|
||||
|
||||
Parameters
|
||||
----------
|
||||
probe : torch.Tensor
|
||||
An MxL probe function for simulating the exit waves
|
||||
obj : torch.Tensor
|
||||
An M'xL' or NxM'xL' object function for simulating the exit waves
|
||||
|
||||
Returns
|
||||
-------
|
||||
exit_wave : torch.Tensor
|
||||
An MxL tensor of the calculated exit waves
|
||||
"""
|
||||
|
||||
# TODO: The upsampling only works for arrays of even dimension!
|
||||
|
||||
# The far-field propagator is just a 2D FFT but with an fftshift
|
||||
fftobj = propagators.far_field(obj)
|
||||
# We calculate the padding that we need to do the upsampling
|
||||
# This is carefully set up to keep the zero-frequency pixel in the correct
|
||||
# location as the overall shape changes. Don't mess with this without
|
||||
# having thought about this carefully.
|
||||
pad2l = probe.shape[-2]//2 - obj.shape[-2]//2
|
||||
pad2r = probe.shape[-2] - obj.shape[-2] - pad2l
|
||||
pad1l = probe.shape[-1]//2 - obj.shape[-1]//2
|
||||
pad1r = probe.shape[-1] - obj.shape[-1] - pad1l
|
||||
|
||||
fftobj = t.nn.functional.pad(fftobj, (pad1l, pad1r, pad2l, pad2r))
|
||||
|
||||
# Again, just an inverse FFT but with an fftshift
|
||||
upsampled_obj = propagators.inverse_far_field(fftobj)
|
||||
|
||||
if obj.dim() >= 3:
|
||||
return probe[None,...] * upsampled_obj
|
||||
else:
|
||||
return probe * upsampled_obj
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.losses.losses import *
|
||||
@@ -0,0 +1,174 @@
|
||||
"""Contains various loss functions to be used for optimization
|
||||
|
||||
It exposes three losses, one returning the mean squared amplitude error, one
|
||||
that returns the mean squared intensity error, and one that returns the
|
||||
maximum likelihood metric for a system with Poisson statistics.
|
||||
|
||||
"""
|
||||
|
||||
import torch as t
|
||||
|
||||
__all__ = ['amplitude_mse', 'intensity_mse', 'poisson_nll']
|
||||
|
||||
|
||||
def amplitude_mse(intensities, sim_intensities, mask=None):
|
||||
""" Returns the mean squared error of a simulated dataset's amplitudes
|
||||
|
||||
Calculates the mean squared error between a given set of
|
||||
measured diffraction intensities and a simulated set.
|
||||
|
||||
This function calculates the mean squared error between their
|
||||
associated amplitudes. Because this is not well defined for negative
|
||||
numbers, make sure that all the intensities are >0 before using this
|
||||
loss. Note that this is actually a sum-squared error, because this
|
||||
formulation makes it vastly simpler to compare error calculations
|
||||
between reconstructions with different minibatch size. I hope to
|
||||
find a better way to do this that is more honest with this
|
||||
cost function, though.
|
||||
|
||||
It can accept intensity and simulated intensity tensors of any shape
|
||||
as long as their shapes match, and the provided mask array can be
|
||||
broadcast correctly along them.
|
||||
|
||||
This is empirically the most useful loss function for most cases
|
||||
|
||||
Parameters
|
||||
----------
|
||||
intensities : torch.Tensor
|
||||
A tensor with measured detector values
|
||||
sim_intensities : torch.Tensor
|
||||
A tensor of simulated detector intensities
|
||||
mask : torch.Tensor
|
||||
A mask with ones for pixels to include and zeros for pixels to exclude
|
||||
|
||||
Returns
|
||||
-------
|
||||
loss : torch.Tensor
|
||||
A single value for the mean amplitude mse
|
||||
"""
|
||||
|
||||
# I know it would be more efficient if this function took in the
|
||||
# amplitudes instead of the intensities, but I want to be consistent
|
||||
# with all the errors working off of the same inputs
|
||||
|
||||
if mask is None:
|
||||
return t.sum((t.sqrt(sim_intensities) -
|
||||
t.sqrt(intensities))**2)
|
||||
else:
|
||||
masked_intensities = intensities.masked_select(mask)
|
||||
return t.sum((t.sqrt(sim_intensities.masked_select(mask)) -
|
||||
t.sqrt(masked_intensities))**2)
|
||||
|
||||
|
||||
|
||||
def intensity_mse(intensities, sim_intensities, mask=None):
|
||||
""" Returns the mean squared error of a simulated dataset's intensities
|
||||
|
||||
Calculates the summed mean squared error between a given set of
|
||||
diffraction intensities - the measured set of detector intensities -
|
||||
and a simulated set of diffraction intensities. This function
|
||||
calculates the mean squared error between the intensities.
|
||||
|
||||
It can accept intensity and simulated intensity tensors of any shape
|
||||
as long as their shapes match, and the provided mask array can be
|
||||
broadcast correctly along them.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
intensities : torch.Tensor
|
||||
A tensor with measured detector intensities.
|
||||
sim_intensities : torch.Tensor
|
||||
A tensor of simulated detector intensities
|
||||
mask : torch.Tensor
|
||||
A mask with ones for pixels to include and zeros for pixels to exclude
|
||||
|
||||
Returns
|
||||
-------
|
||||
loss : torch.Tensor
|
||||
A single value for the mean intensity mse
|
||||
|
||||
"""
|
||||
if mask is None:
|
||||
return t.sum((sim_intensities - intensities)**2) \
|
||||
/ intensities.view(-1).shape[0]
|
||||
else:
|
||||
masked_intensities = intensities.masked_select(mask)
|
||||
return t.sum((sim_intensities.masked_select(mask) -
|
||||
masked_intensities)**2) \
|
||||
/ masked_intensities.shape[0]
|
||||
|
||||
|
||||
|
||||
def poisson_nll(intensities, sim_intensities, mask=None, eps=1e-6, subtract_min=False):
|
||||
""" Returns the Poisson negative log likelihood for a simulated dataset's intensities
|
||||
|
||||
Calculates the overall Poisson maximum likelihood metric using
|
||||
diffraction intensities - the measured set of detector intensities -
|
||||
and a simulated set of intensities. This loss would be appropriate
|
||||
for detectors in a single-photon counting mode, with their output
|
||||
scaled to number of photons
|
||||
|
||||
Note that this calculation ignores the log(intensities!) term in the
|
||||
full expression for Poisson negative log likelihood. This term doesn't
|
||||
change the calculated gradients so isn't worth taking the time to compute
|
||||
|
||||
It can accept intensity and simulated intensity tensors of any shape
|
||||
as long as their shapes match, and the provided mask array can be
|
||||
broadcast correctly along them.
|
||||
|
||||
The default value of eps is 1e-6 - a nonzero value here helps avoid
|
||||
divergence of the log function near zero.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
intensities : torch.Tensor
|
||||
A tensor with measured detector intensities.
|
||||
sim_intensities : torch.Tensor
|
||||
A tensor of simulated detector intensities
|
||||
mask : torch.Tensor
|
||||
A mask with ones for pixels to include and zeros for pixels to exclude
|
||||
eps : float
|
||||
Optional, a small number to add to the simulated intensities
|
||||
|
||||
Returns
|
||||
-------
|
||||
loss : torch.Tensor
|
||||
A single value for the poisson negative log likelihood
|
||||
|
||||
"""
|
||||
#When x.logy gets into the regular build, add it by uncommenting!
|
||||
if mask is None:
|
||||
|
||||
nll = t.sum(sim_intensities+eps -
|
||||
intensities * t.log(sim_intensities+eps)) \
|
||||
/ intensities.view(-1).shape[0]
|
||||
#nll = t.sum(sim_intensities+epsa -
|
||||
# t.xlogy(intensities,sim_intensities+eps)) \
|
||||
# / intensities.view(-1).shape[0]
|
||||
if subtract_min:
|
||||
nll -= t.nansum(intensities - intensities*t.log(intensities))\
|
||||
/ intensities.view(-1).shape[0]
|
||||
#nll -= t.sum(intensities - t.xlogy(intensities,intensities))
|
||||
# We don't need to include the log factorial part here, because
|
||||
# it will get subtracted off in the min anyway.
|
||||
|
||||
return nll
|
||||
else:
|
||||
masked_intensities = intensities.masked_select(mask)
|
||||
masked_sims = sim_intensities.masked_select(mask)
|
||||
|
||||
nll = t.sum(masked_sims + eps - \
|
||||
masked_intensities * t.log(masked_sims+eps)) \
|
||||
/ masked_intensities.shape[0]
|
||||
|
||||
#nll = t.sum(masked_sims + eps - \
|
||||
# t.xlogy(masked_intensities, masked_sims+eps)) \
|
||||
# / masked_intensities.shape[0]
|
||||
|
||||
|
||||
if subtract_min:
|
||||
nll -= t.nansum(masked_intensities -
|
||||
masked_intensities*t.log(masked_intensities)) \
|
||||
/ masked_intensities.shape[0]
|
||||
|
||||
return nll
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.measurements.measurements import *
|
||||
@@ -0,0 +1,159 @@
|
||||
"""This module contains tools to simulate various measurement models
|
||||
|
||||
All the measurements here are safe to use in an automatic differentiation
|
||||
model. There exist tools to simulate detectors with finite saturation
|
||||
thresholds, backgrounds, and more.
|
||||
"""
|
||||
|
||||
import torch as t
|
||||
import numpy as np
|
||||
from torch.nn.functional import avg_pool2d
|
||||
|
||||
#
|
||||
# This file will host tools to turn a propagated wavefield into a measured
|
||||
# intensity pattern on a detector
|
||||
#
|
||||
|
||||
__all__ = ['intensity', 'incoherent_sum', 'quadratic_background']
|
||||
|
||||
|
||||
def intensity(wavefield, detector_slice=None, epsilon=1e-7, saturation=None, oversampling=1):
|
||||
"""Returns the intensity of a wavefield
|
||||
|
||||
The intensity is defined as the magnitude squared of the
|
||||
wavefront. If a detector slice is given, the returned array
|
||||
will only include that slice from the simulated wavefront.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
wavefield : torch.Tensor
|
||||
A JxMxN stack of complex-valued wavefields
|
||||
detector_slice : slice
|
||||
Optional, a slice or tuple of slices defining a section of the simulation to return
|
||||
saturation : float
|
||||
Optional, a maximum saturation value to clamp the resulting intensities to
|
||||
oversampling : int
|
||||
Default 1, the width of the region pixels in the wavefield to bin into a single detector pixel
|
||||
|
||||
Returns
|
||||
-------
|
||||
sim_patterns : torch.Tensor
|
||||
A real MxN array storing the wavefield's intensities
|
||||
"""
|
||||
output = t.abs(wavefield)**2
|
||||
|
||||
# Now we apply oversampling
|
||||
if oversampling != 1:
|
||||
if wavefield.dim() == 2:
|
||||
output = avg_pool2d(output.unsqueeze(0), oversampling)[0]
|
||||
else:
|
||||
output = avg_pool2d(output, oversampling)
|
||||
|
||||
# Then we grab the detector slice
|
||||
if detector_slice is not None:
|
||||
if wavefield.dim() == 2:
|
||||
output = output[detector_slice]
|
||||
else:
|
||||
output = output[(np.s_[:],) + detector_slice]
|
||||
|
||||
# And now saturation
|
||||
if saturation is None:
|
||||
return output + epsilon
|
||||
else:
|
||||
return t.clamp(output + epsilon,0,saturation)
|
||||
|
||||
|
||||
def incoherent_sum(wavefields, detector_slice=None, epsilon=1e-7, saturation=None, oversampling=1):
|
||||
"""Returns the incoherent sum of the intensities of the wavefields
|
||||
|
||||
The intensity is defined as the sum of the magnitudes squared of
|
||||
the wavefields. If a detector slice is given, the returned array
|
||||
will only include that slice from the simulated wavefronts.
|
||||
|
||||
The (-3) index is the set of incoherently adding patterns, and any
|
||||
indexes further to the front correspond to the set of diffraction patterns
|
||||
to measure. The (-2) and (-1) indices are the wavefield, and the final
|
||||
index is the complex index
|
||||
|
||||
Parameters
|
||||
----------
|
||||
wavefields : torch.Tensor
|
||||
An LxJxMxNx stack of complex wavefields
|
||||
detector_slice : slice
|
||||
Optional, a slice or tuple of slices defining a section of the simulation to return
|
||||
saturation : float
|
||||
Optional, a maximum saturation value to clamp the resulting intensities to
|
||||
oversampling : int
|
||||
Default 1, the width of the region pixels in the wavefield to bin into a single detector pixel
|
||||
|
||||
Returns
|
||||
-------
|
||||
sim_patterns : torch.Tensor
|
||||
A real LXMxN array storing the incoherently summed intensities
|
||||
"""
|
||||
|
||||
output = t.sum(t.abs(wavefields)**2,dim=-3)
|
||||
|
||||
# Now we apply oversampling
|
||||
if oversampling != 1:
|
||||
if wavefields.dim() == 3:
|
||||
output = avg_pool2d(output.unsqueeze(0), oversampling)[0]
|
||||
else:
|
||||
output = avg_pool2d(output, oversampling)
|
||||
|
||||
# Then we grab the detector slice
|
||||
if detector_slice is not None:
|
||||
if wavefields.dim() == 3:
|
||||
output = output[detector_slice]
|
||||
else:
|
||||
output = output[(np.s_[:],) + detector_slice]
|
||||
|
||||
if saturation is None:
|
||||
return output + epsilon
|
||||
else:
|
||||
return t.clamp(output + epsilon,0,saturation)
|
||||
|
||||
|
||||
def quadratic_background(wavefield, background, *args, detector_slice=None, measurement=intensity, epsilon=1e-7, saturation=None, oversampling=1):
|
||||
"""Returns the intensity of a wavefield plus a background
|
||||
|
||||
The intensity is calculated via the given measurment function
|
||||
Then, the square of the given background is added. This kind
|
||||
of background model is commonly used to enforce positivity of the
|
||||
background model.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
wavefield : torch.Tensor
|
||||
A JxMxN stack of complex-valued wavefields
|
||||
background : torch.Tensor
|
||||
An tensor storing the square root of the detector background
|
||||
detector_slice : slice
|
||||
Optional, a slice or tuple of slices defining a section of the simulation to return
|
||||
measurement : function
|
||||
Default is measurements.intensity, the measurement function to use.
|
||||
saturation : float
|
||||
Optional, a maximum saturation value to clamp the resulting intensities to
|
||||
oversampling : int
|
||||
Default 1, the width of the region pixels in the wavefield to bin into a single detector pixel
|
||||
|
||||
Returns
|
||||
-------
|
||||
sim_patterns : torch.Tensor
|
||||
A real MxN array storing the wavefield's intensities
|
||||
"""
|
||||
|
||||
if detector_slice is None:
|
||||
output = measurement(wavefield, *args, epsilon=epsilon,
|
||||
oversampling=oversampling) + background**2
|
||||
else:
|
||||
output = measurement(wavefield, *args, detector_slice=detector_slice,
|
||||
epsilon=epsilon, oversampling=oversampling) \
|
||||
+ background**2
|
||||
|
||||
# This has to be done after the background is added, hence we replicate
|
||||
# it here
|
||||
if saturation is None:
|
||||
return output
|
||||
else:
|
||||
return t.clamp(output,0,saturation)
|
||||
@@ -0,0 +1,2 @@
|
||||
from CDTools.tools.plotting.plotting import *
|
||||
|
||||
@@ -0,0 +1,782 @@
|
||||
"""This module contains functions for plotting various important metrics
|
||||
|
||||
All the plotting functions here can accept torch input or numpy input,
|
||||
to facilitate their use both for live inspection of running reconstructions
|
||||
and for after-the-fact analysis. Utilities for plotting complex valued
|
||||
images exist, as well as plotting scan patterns and nanomaps
|
||||
"""
|
||||
|
||||
import torch as t
|
||||
import numpy as np
|
||||
import matplotlib.pyplot as plt
|
||||
from matplotlib.colors import hsv_to_rgb
|
||||
from matplotlib.widgets import Slider
|
||||
from matplotlib import ticker, patheffects
|
||||
|
||||
|
||||
__all__ = ['colorize', 'plot_amplitude', 'plot_phase',
|
||||
'plot_colorized', 'plot_translations', 'get_units_factor',
|
||||
'plot_nanomap', 'plot_real', 'plot_imag',
|
||||
'plot_nanomap_with_images']
|
||||
|
||||
|
||||
def colorize(z):
|
||||
""" Returns RGB values for a complex color plot given a complex array
|
||||
This function returns a set of RGB values that can be used directly
|
||||
in a call to imshow based on an input complex numpy array (not a
|
||||
torch tensor representing a complex field)
|
||||
|
||||
Parameters
|
||||
----------
|
||||
z : array
|
||||
A complex-valued array
|
||||
Returns
|
||||
-------
|
||||
rgb : list(array)
|
||||
A list of arrays for the R,G, and B channels of an image
|
||||
"""
|
||||
|
||||
amp = np.abs(z)
|
||||
rmin = 0
|
||||
rmax = np.max(amp)
|
||||
amp = np.where(amp < rmin, rmin, amp)
|
||||
amp = np.where(amp > rmax, rmax, amp)
|
||||
ph = np.angle(z, deg=1) + 90
|
||||
# HSV are values in range [0,1]
|
||||
h = (ph % 360) / 360
|
||||
s = 0.85 * np.ones_like(h)
|
||||
v = (amp - rmin) / (rmax - rmin)
|
||||
|
||||
return hsv_to_rgb(np.dstack((h,s,v)))
|
||||
|
||||
|
||||
def get_units_factor(units):
|
||||
"""Gets the multiplicative factor associated with a length unit
|
||||
|
||||
Parameters
|
||||
----------
|
||||
units : str
|
||||
The abbreviation for the unit type
|
||||
|
||||
Returns
|
||||
-------
|
||||
factor : float
|
||||
The factor meters / (unit)
|
||||
"""
|
||||
|
||||
u = units.lower()
|
||||
if u=='m':
|
||||
factor=1
|
||||
if u=='cm':
|
||||
factor=1e2
|
||||
if u=='mm':
|
||||
factor=1e3
|
||||
if u=='um' or u=="$\\mu$m":
|
||||
factor=1e6
|
||||
if u=='nm':
|
||||
factor=1e9
|
||||
if u=='a':
|
||||
factor=1e10
|
||||
if u=='pm':
|
||||
factor=1e12
|
||||
return factor
|
||||
|
||||
|
||||
def plot_image(im, plot_func=lambda x: x, fig=None, basis=None, units='$\\mu$m', cmap='viridis', cmap_label=None, interpolation=None, **kwargs):
|
||||
"""Plots an image with a colorbar and on an appropriate spatial grid
|
||||
|
||||
If a figure is given explicitly, it will clear that existing figure and
|
||||
plot over it. Otherwise, it will generate a new figure.
|
||||
|
||||
If a basis is explicitly passed, the image will be plotted in real-space
|
||||
coordinates
|
||||
|
||||
Finally, if a function is passed to the plot_func argument, this function
|
||||
will be called on each slice of data before it is plotted. This is used
|
||||
internally to enable the plot_real, plot_image, plot_phase, etc. functions.
|
||||
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : array
|
||||
An complex array with dimensions NxM
|
||||
plot_func : callable
|
||||
A function which maps numpy arrays to the image to be plotted
|
||||
fig : matplotlib.figure.Figure
|
||||
Default is a new figure, a matplotlib figure to use to plot
|
||||
basis : np.array
|
||||
Optional, the 3x2 probe basis
|
||||
units : str
|
||||
The length units to mark on the plot, default is um
|
||||
cmap : str
|
||||
Default is 'viridis', the colormap to plot with
|
||||
cmap_label : str
|
||||
What to label the colorbar when plotting
|
||||
interpolation : str
|
||||
What interpolation to use for imshow
|
||||
\\**kwargs
|
||||
All other args are passed to fig.add_subplot(111, \\**kwargs)
|
||||
|
||||
Returns
|
||||
-------
|
||||
used_fig : matplotlib.figure.Figure
|
||||
The figure object that was actually plotted to.
|
||||
"""
|
||||
|
||||
# convert to numpy
|
||||
if isinstance(im, t.Tensor):
|
||||
# If final dimension is 2, assume it is a complex array. If not,
|
||||
# assume it represents a real array
|
||||
if im.shape[-1] == 2:
|
||||
im = im.detach().cpu().numpy()
|
||||
else:
|
||||
im = im.detach().cpu().numpy()
|
||||
|
||||
if fig is None:
|
||||
fig = plt.figure()
|
||||
ax = fig.add_subplot(111, **kwargs)
|
||||
|
||||
# This nukes everything and updates either the appropriate image from the
|
||||
# stack of images, or the only image if only a single image has been
|
||||
# given
|
||||
def make_plot(idx):
|
||||
plt.figure(fig.number)
|
||||
title = plt.gca().get_title()
|
||||
fig.clear()
|
||||
|
||||
|
||||
# If im only has two dimensions, this reshape will add a leading
|
||||
# dimension, and update will be called on index 0. If it has 3 or more
|
||||
# dimensions, then all the leading dimensions will be compressed into
|
||||
# one long dimension which can be scrolled through.
|
||||
s = im.shape
|
||||
reshaped_im = im.reshape(-1,s[-2],s[-1])
|
||||
num_images = reshaped_im.shape[0]
|
||||
fig.plot_idx = idx % num_images
|
||||
|
||||
to_plot = plot_func(reshaped_im[fig.plot_idx])
|
||||
|
||||
#Plot in a basis if it exists, otherwise dont
|
||||
if basis is not None:
|
||||
if isinstance(basis,t.Tensor):
|
||||
np_basis = basis.detach().cpu().numpy()
|
||||
else:
|
||||
np_basis = basis
|
||||
# This fails if the basis is not rectangular
|
||||
basis_norm = np.linalg.norm(np_basis, axis = 0)
|
||||
basis_norm = basis_norm * get_units_factor(units)
|
||||
|
||||
extent = [0, im.shape[-1]*basis_norm[1], 0,
|
||||
im.shape[-2]*basis_norm[0]]
|
||||
else:
|
||||
extent=None
|
||||
|
||||
plt.imshow(to_plot, cmap = cmap, extent = extent, interpolation=interpolation)
|
||||
cbar = plt.colorbar()
|
||||
if cmap_label is not None:
|
||||
cbar.set_label(cmap_label)
|
||||
|
||||
if basis is not None:
|
||||
plt.xlabel('X (' + units + ')')
|
||||
plt.ylabel('Y (' + units + ')')
|
||||
else:
|
||||
plt.xlabel('j (pixels)')
|
||||
plt.ylabel('i (pixels)')
|
||||
|
||||
|
||||
plt.title(title)
|
||||
|
||||
if len(im.shape) >= 3:
|
||||
plt.text(0.03, 0.03, str(fig.plot_idx), fontsize=14, transform=plt.gcf().transFigure)
|
||||
return fig
|
||||
|
||||
if hasattr(fig, 'plot_idx'):
|
||||
result = make_plot(fig.plot_idx)
|
||||
else:
|
||||
result = make_plot(0)
|
||||
|
||||
update = make_plot
|
||||
|
||||
|
||||
def on_action(event):
|
||||
if not hasattr(event, 'button'):
|
||||
event.button = None
|
||||
if not hasattr(event, 'key'):
|
||||
event.key = None
|
||||
|
||||
if event.key == 'up' or event.button == 'up':
|
||||
update(fig.plot_idx - 1)
|
||||
elif event.key == 'down' or event.button == 'down':
|
||||
update(fig.plot_idx + 1)
|
||||
plt.draw()
|
||||
|
||||
if len(im.shape) >=3:
|
||||
if not hasattr(fig,'my_callbacks'):
|
||||
fig.my_callbacks = []
|
||||
|
||||
for cid in fig.my_callbacks:
|
||||
fig.canvas.mpl_disconnect(cid)
|
||||
fig.my_callbacks = []
|
||||
fig.my_callbacks.append(fig.canvas.mpl_connect('key_press_event',on_action))
|
||||
fig.my_callbacks.append(fig.canvas.mpl_connect('scroll_event',on_action))
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def plot_real(im, fig = None, basis=None, units='$\\mu$m', cmap='viridis', cmap_label='Real Part (a.u.)', **kwargs):
|
||||
"""Plots the real part of a complex array with dimensions NxM
|
||||
|
||||
If a figure is given explicitly, it will clear that existing figure and
|
||||
plot over it. Otherwise, it will generate a new figure.
|
||||
|
||||
If a basis is explicitly passed, the image will be plotted in real-space
|
||||
coordinates
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : array
|
||||
An complex array with dimensions NxM
|
||||
fig : matplotlib.figure.Figure
|
||||
Default is a new figure, a matplotlib figure to use to plot
|
||||
basis : np.array
|
||||
Optional, the 3x2 probe basis
|
||||
units : str
|
||||
The length units to mark on the plot, default is um
|
||||
cmap : str
|
||||
Default is 'viridis', the colormap to plot with
|
||||
cmap_label : str
|
||||
What to label the colorbar when plotting
|
||||
\\**kwargs
|
||||
All other args are passed to fig.add_subplot(111, \\**kwargs)
|
||||
|
||||
Returns
|
||||
-------
|
||||
used_fig : matplotlib.figure.Figure
|
||||
The figure object that was actually plotted to.
|
||||
"""
|
||||
plot_func = lambda x: np.real(x)
|
||||
return plot_image(im, plot_func=plot_func, fig=fig, basis=basis,
|
||||
units=units, cmap=cmap, cmap_label=cmap_label,
|
||||
**kwargs)
|
||||
|
||||
|
||||
|
||||
def plot_imag(im, fig = None, basis=None, units='$\\mu$m', cmap='viridis', cmap_label='Imaginary Part (a.u.)', **kwargs):
|
||||
"""Plots the imaginary part of a complex array with dimensions NxM
|
||||
|
||||
If a figure is given explicitly, it will clear that existing figure and
|
||||
plot over it. Otherwise, it will generate a new figure.
|
||||
|
||||
If a basis is explicitly passed, the image will be plotted in real-space
|
||||
coordinates
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : array
|
||||
An complex array with dimensions NxM
|
||||
fig : matplotlib.figure.Figure
|
||||
Default is a new figure, a matplotlib figure to use to plot
|
||||
basis : np.array
|
||||
Optional, the 3x2 probe basis
|
||||
units : str
|
||||
The length units to mark on the plot, default is um
|
||||
cmap : str
|
||||
Default is 'viridis', the colormap to plot with
|
||||
cmap_label : str
|
||||
What to label the colorbar when plotting
|
||||
\\**kwargs
|
||||
All other args are passed to fig.add_subplot(111, \\**kwargs)
|
||||
|
||||
Returns
|
||||
-------
|
||||
used_fig : matplotlib.figure.Figure
|
||||
The figure object that was actually plotted to.
|
||||
"""
|
||||
plot_func = lambda x: np.imag(x)
|
||||
return plot_image(im, plot_func=plot_func, fig=fig, basis=basis,
|
||||
units=units, cmap=cmap, cmap_label=cmap_label,
|
||||
**kwargs)
|
||||
|
||||
|
||||
def plot_amplitude(im, fig = None, basis=None, units='$\\mu$m', cmap='viridis', cmap_label='Amplitude (a.u.)', **kwargs):
|
||||
"""Plots the amplitude of a complex array with dimensions NxM
|
||||
|
||||
If a figure is given explicitly, it will clear that existing figure and
|
||||
plot over it. Otherwise, it will generate a new figure.
|
||||
|
||||
If a basis is explicitly passed, the image will be plotted in real-space
|
||||
coordinates.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : array
|
||||
An complex array with dimensions NxM
|
||||
fig : matplotlib.figure.Figure
|
||||
Default is a new figure, a matplotlib figure to use to plot
|
||||
basis : np.array
|
||||
Optional, the 3x2 probe basis
|
||||
units : str
|
||||
The length units to mark on the plot, default is um
|
||||
cmap : str
|
||||
Default is 'viridis', the colormap to plot with
|
||||
cmap_label : str
|
||||
What to label the colorbar when plotting
|
||||
\\**kwargs
|
||||
All other args are passed to fig.add_subplot(111, \\**kwargs)
|
||||
|
||||
Returns
|
||||
-------
|
||||
used_fig : matplotlib.figure.Figure
|
||||
The figure object that was actually plotted to.
|
||||
"""
|
||||
plot_func = lambda x: np.absolute(x)
|
||||
return plot_image(im, plot_func=plot_func, fig=fig, basis=basis,
|
||||
units=units, cmap=cmap, cmap_label=cmap_label,
|
||||
**kwargs)
|
||||
|
||||
|
||||
def plot_phase(im, fig=None, basis=None, units='$\\mu$m', cmap='auto', cmap_label='Phase (rad)', **kwargs):
|
||||
""" Plots the phase of a complex array with dimensions NxMx2
|
||||
|
||||
If a figure is given explicitly, it will clear that existing figure and
|
||||
plot over it. Otherwise, it will generate a new figure.
|
||||
|
||||
If a basis is explicitly passed, the image will be plotted in real-space
|
||||
coordinates
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : array
|
||||
An complex array with dimensions NxM
|
||||
fig : matplotlib.figure.Figure
|
||||
Default is a new figure, a matplotlib figure to use to plot
|
||||
basis : np.array
|
||||
Optional, the 3x2 probe basis
|
||||
units : str
|
||||
The length units to mark on the plot, default is um
|
||||
cmap : str
|
||||
Default is 'viridis', the colormap to plot with
|
||||
cmap_label : str
|
||||
What to label the colorbar when plotting
|
||||
\\**kwargs
|
||||
All other args are passed to fig.add_subplot(111, \\**kwargs)
|
||||
|
||||
Returns
|
||||
-------
|
||||
used_fig : matplotlib.figure.Figure
|
||||
The figure object that was actually plotted to.
|
||||
"""
|
||||
if cmap == 'auto':
|
||||
if 'twilight' in plt.colormaps():
|
||||
cmap = 'twilight'
|
||||
elif 'hsv' in plt.colormaps():
|
||||
cmap = 'hsv'
|
||||
else:
|
||||
raise AttributeError('Neither twilight or hsv colormap exists in this screwed up matplotlib install')
|
||||
|
||||
plot_func = lambda x: np.angle(x)
|
||||
return plot_image(im, plot_func=plot_func, fig=fig, basis=basis,
|
||||
units=units, cmap=cmap, cmap_label=cmap_label,
|
||||
**kwargs)
|
||||
|
||||
|
||||
def plot_amplitude_surfacenorm():
|
||||
pass
|
||||
|
||||
def plot_colorized(im, fig=None, basis=None, units='$\\mu$m', **kwargs):
|
||||
""" Plots the colorized version of a complex array with dimensions NxM
|
||||
|
||||
The darkness corresponds to the intensity of the image, and the color
|
||||
corresponds to the phase.
|
||||
|
||||
If a figure is given explicitly, it will clear that existing figure and
|
||||
plot over it. Otherwise, it will generate a new figure.
|
||||
|
||||
If a basis is explicitly passed, the image will be plotted in real-space
|
||||
coordinates
|
||||
|
||||
Parameters
|
||||
----------
|
||||
im : array
|
||||
An complex array with dimensions NxM
|
||||
fig : matplotlib.figure.Figure
|
||||
Default is a new figure, a matplotlib figure to use to plot
|
||||
basis : np.array
|
||||
Optional, the 3x2 probe basis
|
||||
units : str
|
||||
The length units to mark on the plot, default is um
|
||||
\\**kwargs
|
||||
All other args are passed to fig.add_subplot(111, \\**kwargs)
|
||||
|
||||
Returns
|
||||
-------
|
||||
used_fig : matplotlib.figure.Figure
|
||||
The figure object that was actually plotted to.
|
||||
"""
|
||||
plot_func = lambda x: colorize(x)
|
||||
return plot_image(im, plot_func=plot_func, fig=fig, basis=basis,
|
||||
units=units, **kwargs)
|
||||
|
||||
|
||||
def plot_translations(translations, fig=None, units='$\\mu$m', lines=True, invert_xaxis=True, **kwargs):
|
||||
"""Plots a set of probe translations in a nicely formatted way
|
||||
|
||||
Parameters
|
||||
----------
|
||||
translations : array
|
||||
An Nx2 or Nx3 set of translations in real space
|
||||
fig : matplotlib.figure.Figure
|
||||
Default is a new figure, a matplotlib figure to use to plot
|
||||
units : str
|
||||
Default is um, units to report in (assuming input in m)
|
||||
lines : bool
|
||||
Whether to plot lines indicating the path taken
|
||||
invert_xaxis : bool
|
||||
Default is True. This flips the x axis to match the convention from .cxi files of viewing the image from the beam's perspective
|
||||
\\**kwargs
|
||||
All other args are passed to fig.add_subplot(111, \\**kwargs)
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
used_fig : matplotlib.figure.Figure
|
||||
The figure object that was actually plotted to.
|
||||
"""
|
||||
|
||||
factor = get_units_factor(units)
|
||||
|
||||
if fig is None:
|
||||
fig = plt.figure()
|
||||
ax = fig.add_subplot(111, **kwargs)
|
||||
else:
|
||||
plt.figure(fig.number)
|
||||
plt.gcf().clear()
|
||||
|
||||
if isinstance(translations, t.Tensor):
|
||||
translations = translations.detach().cpu().numpy()
|
||||
|
||||
translations = translations * factor
|
||||
plt.plot(translations[:,0], translations[:,1],'k.')
|
||||
if invert_xaxis:
|
||||
plt.gca().invert_xaxis()
|
||||
|
||||
if lines:
|
||||
plt.plot(translations[:,0], translations[:,1],'b-', linewidth=0.5)
|
||||
plt.xlabel('X (' + units + ')')
|
||||
plt.ylabel('Y (' + units + ')')
|
||||
|
||||
return fig
|
||||
|
||||
|
||||
def plot_nanomap(translations, values, fig=None, units='$\\mu$m', convention='probe', invert_xaxis=True):
|
||||
"""Plots a set of nanomap data in a flexible way
|
||||
|
||||
Parameters
|
||||
----------
|
||||
translations : array
|
||||
An Nx2 or Nx3 set of translations in real space
|
||||
values : array
|
||||
A length-N object of values associated with the translations
|
||||
fig : matplotlib.figure.Figure
|
||||
Default is a new figure, a matplotlib figure to use to plot
|
||||
units : str
|
||||
Default is um, units to report in (assuming input in m)
|
||||
convention : str
|
||||
Default is 'probe', alternative is 'obj'. Whether the translations refer to the probe or object.
|
||||
invert_xaxis : bool
|
||||
Default is True. This flips the x axis to match the convention from .cxi files of viewing the image from the beam's perspective
|
||||
|
||||
Returns
|
||||
-------
|
||||
used_fig : matplotlib.figure.Figure
|
||||
The figure object that was actually plotted to.
|
||||
"""
|
||||
|
||||
if fig is None:
|
||||
fig = plt.figure()
|
||||
else:
|
||||
plt.figure(fig.number)
|
||||
plt.gcf().clear()
|
||||
|
||||
factor = get_units_factor(units)
|
||||
|
||||
bbox = fig.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
|
||||
if isinstance(translations, t.Tensor):
|
||||
trans = translations.detach().cpu().numpy()
|
||||
else:
|
||||
trans = np.array(translations)
|
||||
|
||||
if isinstance(values, t.Tensor):
|
||||
values = values.detach().cpu().numpy()
|
||||
else:
|
||||
values = np.array(values)
|
||||
|
||||
if convention.lower() != 'probe':
|
||||
trans = trans * -1
|
||||
|
||||
s = bbox.width * bbox.height / trans.shape[0] * 72**2 #72 is points per inch
|
||||
s /= 4 # A rough value to make the size work out
|
||||
|
||||
plt.scatter(factor * trans[:,0],factor * trans[:,1],s=s,c=values)
|
||||
if invert_xaxis:
|
||||
plt.gca().invert_xaxis()
|
||||
|
||||
plt.gca().set_facecolor('k')
|
||||
plt.xlabel('Translation x (' + units + ')')
|
||||
plt.ylabel('Translation y (' + units + ')')
|
||||
plt.colorbar()
|
||||
|
||||
return fig
|
||||
|
||||
|
||||
def plot_nanomap_with_images(translations, get_image_func, values=None, mask=None, basis=None, fig=None, nanomap_units='$\\mu$m', image_units='$\\mu$m', convention='probe', image_title='Image', image_colorbar_title='Image Amplitude', nanomap_colorbar_title='Integrated Intensity', cmap='viridis', **kwargs):
|
||||
"""Plots a nanomap, with an image or stack of images for each point
|
||||
|
||||
In many situations, ptychography data or the output of ptychography
|
||||
reconstructions is formatted as a set of images associated with various
|
||||
points in real space. This function is designed to allow for browsing
|
||||
through this kind of data, by making it possible to visualize a
|
||||
|
||||
"""
|
||||
|
||||
# This should pull heavily from the dataset.inspect function
|
||||
# In fact, I should be able to replace most of that function with a
|
||||
# call to this function once it's built
|
||||
# We start by making the figure and axes
|
||||
|
||||
# The key will be writing this so it works okay when called in "update"
|
||||
# mode, i.e. on a figure that already has this thing showing.
|
||||
|
||||
if fig is None:
|
||||
fig = plt.figure(figsize=(8,5.3))
|
||||
else:
|
||||
plt.figure(fig.number)
|
||||
plt.gcf().clear()
|
||||
if hasattr(fig, 'nanomap_cids'):
|
||||
for cid in fig.nanomap_cids:
|
||||
fig.canvas.mpl_disconnect(cid)
|
||||
|
||||
# Does figsize work with the fig.subplots, or just for plt.subplots?
|
||||
axes = fig.subplots(1,2)
|
||||
|
||||
fig.tight_layout(rect=[0.04, 0.09, 0.98, 0.96])
|
||||
plt.subplots_adjust(wspace=0.25) #avoids overlap of labels with plots
|
||||
axslider = plt.axes([0.15,0.06,0.75,0.03])
|
||||
|
||||
# This gets the set of sizes for the points in the nanomap
|
||||
def calculate_sizes(idx):
|
||||
bbox = axes[0].get_window_extent().transformed(fig.dpi_scale_trans.inverted())
|
||||
s0 = bbox.width * bbox.height / translations.shape[0] * 72**2 #72 is points per inch
|
||||
s0 /= 4 # A rough value to make the size work out
|
||||
s = np.ones(translations.shape[0]) * s0
|
||||
|
||||
s[idx] *= 4
|
||||
return s
|
||||
|
||||
|
||||
def update_colorbar(im):
|
||||
#
|
||||
# This solves the problem of the colorbar being changed
|
||||
# when the forward and back buttons are used!!!
|
||||
#
|
||||
if hasattr(im, 'norecurse') and im.norecurse:
|
||||
im.norecurse=False
|
||||
return
|
||||
|
||||
im.norecurse=True
|
||||
# This is needed to update the colorbar
|
||||
# only change limits if array contains multiple values
|
||||
if np.min(im.get_array()) != np.max(im.get_array()):
|
||||
im.set_clim(vmin=np.min(im.get_array()),
|
||||
vmax=np.max(im.get_array()))
|
||||
|
||||
#
|
||||
# The meatiest part of this program, here we just go through and
|
||||
# set up the plot how we want it
|
||||
#
|
||||
|
||||
# First we set up the left-hand plot, which shows an overview map
|
||||
axes[0].set_title('Relative Displacement Map')
|
||||
|
||||
translations = translations.detach().cpu().numpy()
|
||||
|
||||
if convention.lower() != 'probe':
|
||||
translations = translations * -1
|
||||
|
||||
s = calculate_sizes(0)
|
||||
|
||||
nanomap_units_factor = get_units_factor(nanomap_units)
|
||||
nanomap = axes[0].scatter(nanomap_units_factor * translations[:,0],
|
||||
nanomap_units_factor * translations[:,1],
|
||||
s=s,c=values, picker=True)
|
||||
|
||||
axes[0].invert_xaxis()
|
||||
axes[0].set_facecolor('k')
|
||||
axes[0].set_xlabel('Translation x ('+nanomap_units+')', labelpad=1)
|
||||
axes[0].set_ylabel('Translation y ('+nanomap_units+')', labelpad=1)
|
||||
cb1 = plt.colorbar(nanomap, ax=axes[0], orientation='horizontal',
|
||||
format='%.2e',
|
||||
ticks=ticker.LinearLocator(numticks=5),
|
||||
pad=0.17,fraction=0.1)
|
||||
cb1.ax.set_title(nanomap_colorbar_title, size="medium", pad=5)
|
||||
cb1.ax.tick_params(labelrotation=20)
|
||||
if values is None:
|
||||
# This seems to do a good job of leaving the appropriate space
|
||||
# where the colorbar should have been to avoid stretching the
|
||||
# nanomap plot, while still not showing the (now useless) colorbar.
|
||||
cb1.remove()
|
||||
|
||||
# Now we set up the second plot, which shows the individual
|
||||
# diffraction patterns
|
||||
axes[1].set_title(image_title)
|
||||
#Plot in a basis if it exists, otherwise dont
|
||||
if basis is not None:
|
||||
axes[1].set_xlabel('X (' + image_units + ')')
|
||||
axes[1].set_ylabel('Y (' + image_units + ')')
|
||||
|
||||
example_im = get_image_func(0)
|
||||
if isinstance(example_im, t.Tensor):
|
||||
example_im = example_im.cpu().numpy()
|
||||
|
||||
if isinstance(basis,t.Tensor):
|
||||
np_basis = basis.detach().cpu().numpy()
|
||||
else:
|
||||
np_basis = basis
|
||||
# This fails if the basis is not rectangular
|
||||
basis_norm = np.linalg.norm(np_basis, axis = 0)
|
||||
basis_norm = basis_norm * get_units_factor(image_units)
|
||||
|
||||
extent = [0, example_im.shape[-1]*basis_norm[1], 0,
|
||||
example_im.shape[-2]*basis_norm[0]]
|
||||
else:
|
||||
axes[1].set_xlabel('j (pixels)')
|
||||
axes[1].set_ylabel('i (pixels)')
|
||||
extent=None
|
||||
|
||||
im=get_image_func(0)
|
||||
if len(im.shape) >= 3:
|
||||
im_idx=0
|
||||
axes[1].image_idx = im_idx
|
||||
im = im.reshape(-1,im.shape[-2],im.shape[-1])[im_idx]
|
||||
axes[1].text_box = axes[1].text(0.98, 0.98, str(im_idx), color='w',
|
||||
fontsize=14,
|
||||
horizontalalignment='right',
|
||||
verticalalignment='top',
|
||||
transform=axes[1].transAxes)
|
||||
axes[1].text_box.set_path_effects(
|
||||
[patheffects.Stroke(linewidth=2, foreground='black'),
|
||||
patheffects.Normal()])
|
||||
|
||||
meas = axes[1].imshow(im, extent=extent, cmap=cmap)
|
||||
|
||||
cb2 = plt.colorbar(meas, ax=axes[1], orientation='horizontal',
|
||||
format='%.2e',
|
||||
ticks=ticker.LinearLocator(numticks=5),
|
||||
pad=0.17,fraction=0.1)
|
||||
cb2.ax.tick_params(labelrotation=20)
|
||||
cb2.ax.set_title(image_colorbar_title, size="medium", pad=5)
|
||||
cb2.ax.callbacks.connect('xlim_changed', lambda ax: update_colorbar(meas))
|
||||
|
||||
# This function handles all the updating, except for moving the
|
||||
# slider value. This is done because the slider widget is
|
||||
# ultimately responsible for triggering an update, so all other
|
||||
# updates are done by changing the slider widget value which
|
||||
# then triggers this
|
||||
def update(idx, im_idx=None):
|
||||
# We have to explicitly make it an integer because the slider will
|
||||
# output floats (even if they are still integer-valued)
|
||||
idx = int(idx)
|
||||
|
||||
# Get the new data for this index
|
||||
im = get_image_func(idx)
|
||||
if len(im.shape) >= 3:
|
||||
if im_idx == None and hasattr(axes[1],'image_idx'):
|
||||
im_idx = axes[1].image_idx
|
||||
elif im_idx == None:
|
||||
im_idx=0
|
||||
axes[1].image_idx = im_idx
|
||||
axes[1].text_box.set_text(str(im_idx))
|
||||
im = im.reshape(-1,im.shape[-2],im.shape[-1])[im_idx]
|
||||
|
||||
# Now we resize the nanomap to show the new selection
|
||||
axes[0].collections[0].set_sizes(calculate_sizes(idx))
|
||||
|
||||
# And we update the data in the image as well
|
||||
|
||||
ax_im = axes[1].images[-1]
|
||||
ax_im.set_data(im)
|
||||
update_colorbar(ax_im)
|
||||
|
||||
|
||||
#
|
||||
# Now we define the functions to handle various kinds of events
|
||||
# that can be thrown our way
|
||||
#
|
||||
|
||||
# We start by creating the slider here, so it can be used
|
||||
# by the update hooks.
|
||||
slider = Slider(axslider, 'Image #', 0, translations.shape[0]-1, valstep=1, valfmt="%d")
|
||||
|
||||
# This handles scroll wheel and keypress events
|
||||
def on_action(event):
|
||||
im = get_image_func(0)
|
||||
if event.inaxes is axes[1] and len(im.shape) >=3:
|
||||
# This is triggered if the data to display has more than 2
|
||||
# dimensions (i.e. is an image stack) and the event originates
|
||||
# while the mouse is within the image display
|
||||
im = im.reshape(-1,im.shape[-2],im.shape[-1])
|
||||
im_idx = axes[1].image_idx
|
||||
|
||||
if event.key == 'up' or event.button == 'up' \
|
||||
or event.key == 'left':
|
||||
im_idx = (im_idx - 1) % im.shape[0]
|
||||
if event.key == 'down' or event.button == 'down' \
|
||||
or event.key == 'right':
|
||||
im_idx = (im_idx + 1) % im.shape[0]
|
||||
|
||||
axes[1].image_idx=im_idx
|
||||
slider.set_val(slider.val)#update(slider.val,im_idx=im_idx)
|
||||
return # This prevents the rest from also happening
|
||||
|
||||
# Otherwise the if statements can throw errors when the
|
||||
# event type isn't right, this way they just don't trigger
|
||||
if not hasattr(event, 'button'):
|
||||
event.button = None
|
||||
if not hasattr(event, 'key'):
|
||||
event.key = None
|
||||
|
||||
if event.key == 'up' or event.button == 'up' or event.key == 'left':
|
||||
idx = slider.val - 1
|
||||
elif event.key == 'down' or event.button == 'down' or event.key == 'right':
|
||||
idx = slider.val + 1
|
||||
else:
|
||||
# This prevents errors from being thrown on irrelevant key
|
||||
# or mouse input
|
||||
return
|
||||
|
||||
# Handle the wraparound and trigger the update
|
||||
idx = int(idx) % translations.shape[0]
|
||||
slider.set_val(idx)
|
||||
|
||||
# This handles "pick" events in the nanomap
|
||||
def on_pick(event):
|
||||
# If we don't filter on type of event, this will also capture,
|
||||
# for example, scroll events that happen over the nanomap
|
||||
if event.mouseevent.button == 1:
|
||||
slider.set_val(event.ind[0])
|
||||
|
||||
|
||||
# Here we connect the various update functions
|
||||
cid1 = fig.canvas.mpl_connect('pick_event',on_pick)
|
||||
cid2 = fig.canvas.mpl_connect('key_press_event',on_action)
|
||||
cid3 = fig.canvas.mpl_connect('scroll_event',on_action)
|
||||
# It's so dumb that matplotlib doesn't automatically track this for you
|
||||
fig.nanomap_cids = [cid1,cid2,cid3]
|
||||
slider.on_changed(update)
|
||||
|
||||
# Throw an extra update into the mix just to get rid of any things
|
||||
# (like the nanomap dot sizes) that otherwise would change on the
|
||||
# first update
|
||||
update(0)
|
||||
|
||||
return fig
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.polarization.polarization import *
|
||||
@@ -0,0 +1,217 @@
|
||||
import numpy as numpy
|
||||
import torch as t
|
||||
# Abe - again, we don't need math here. replace with torch-native functions
|
||||
# in all the definitions here. We have to use torch here if we want to be
|
||||
# able to calculate derivatives w.r.t. the polarizer angle, say.
|
||||
import math
|
||||
from math import sin
|
||||
from math import cos
|
||||
|
||||
__all__ = ['apply_linear_polarizer',
|
||||
'apply_phase_retardance',
|
||||
'apply_half_wave_plate',
|
||||
'apply_quarter_wave_plate',
|
||||
'apply_circular_polarizer',
|
||||
'apply_jones_matrix',
|
||||
'generate_linear_polarizer',
|
||||
'generate_birefringent_obj']
|
||||
|
||||
|
||||
def generate_linear_polarizer(pol_angle):
|
||||
single_angle = False
|
||||
|
||||
pol_angle = t.as_tensor(pol_angle).to(dtype=t.float32)
|
||||
if pol_angle.dim() == 0:
|
||||
pol_angle = t.unsqueeze(pol_angle,0)
|
||||
single_angle = True
|
||||
|
||||
pol_angle_rad = t.deg2rad(pol_angle)
|
||||
a = t.cos(pol_angle_rad) ** 2
|
||||
b = t.sin(pol_angle_rad) * t.cos(pol_angle_rad)
|
||||
c = b
|
||||
d = t.sin(pol_angle_rad) ** 2
|
||||
ab = t.stack((a, b), dim=-1)
|
||||
cd = t.stack((c, d), dim=-1)
|
||||
jones_matrices = t.stack((ab, cd), dim=-2)
|
||||
if single_angle:
|
||||
return jones_matrices[0].to(dtype=t.cfloat)
|
||||
else:
|
||||
return jones_matrices.to(dtype=t.cfloat)
|
||||
|
||||
|
||||
def apply_linear_polarizer(probe, polarizer, multiple_modes=True, transpose=True):
|
||||
"""
|
||||
Applies a linear polarizer to the probe
|
||||
|
||||
Parameters:
|
||||
----------
|
||||
probe: t.Tensor
|
||||
A (N)(P)x2xMxL tensor representing the probe, MxL - the size of the probe
|
||||
The angle between the fast-axis of the linear polarizer and the horizontal axis
|
||||
polarizer: t.Tensor
|
||||
A 1D tensor (N) representing the polarizer angles for each of the patterns (or a single tensor of shape (1))
|
||||
|
||||
Returns:
|
||||
--------
|
||||
linearly polarized probe: t.Tensor
|
||||
(N)(P)x2x1xMxL
|
||||
"""
|
||||
jones_matrices = generate_linear_polarizer(polarizer)
|
||||
return apply_jones_matrix(probe, jones_matrices, transpose=transpose, multiple_modes=multiple_modes)
|
||||
|
||||
|
||||
def apply_jones_matrix(probe, jones_matrix, transpose=True, multiple_modes=True):
|
||||
# print('probe', probe.shape, 'jones matrix', jones_matrix.shape)
|
||||
# if jones_matrix.shape == t.Size([5, 2, 2, 2, 2]):
|
||||
# print('probe', probe.shape, 'jones', jones_matrix.shape)
|
||||
# print('JONES', jones_matrix)
|
||||
"""
|
||||
Applies a given Jones matrix to the probe
|
||||
|
||||
Parameters:
|
||||
----------
|
||||
probe: t.Tensor
|
||||
A (N)(P)x2xMxL tensor representing the probe
|
||||
jones_matrix: t.tensor
|
||||
(N)x2x2x(M)x(L)
|
||||
|
||||
Returns:
|
||||
--------
|
||||
a probe with the jones matrix applied: t.Tensor
|
||||
(N)(P)x2xMxL
|
||||
|
||||
"""
|
||||
if transpose:
|
||||
if jones_matrix.dim() < 4:
|
||||
jones_matrix = jones_matrix[..., None, None]
|
||||
if multiple_modes:
|
||||
jones_matrix = jones_matrix.unsqueeze(-5)
|
||||
probe = probe[..., None, :, :]
|
||||
# if jones matrices do not differ from pattern to pattern
|
||||
if probe.dim() > jones_matrix.dim():
|
||||
jones_matrix = jones_matrix.unsqueeze(0)
|
||||
# vice versa
|
||||
elif jones_matrix.dim() > probe.dim():
|
||||
probe = probe.unsqueeze(0)
|
||||
# print('apply jonesmatrix: probe', probe.shape, 'matrix:', jones_matrix)
|
||||
jones_matrix = jones_matrix.transpose(-1, -3).transpose(-2, -4)
|
||||
probe = probe.transpose(-1, -3).transpose(-2, -4)
|
||||
output = t.matmul(jones_matrix, probe).transpose(-2, -4).transpose(-1, -3).squeeze(-3)
|
||||
|
||||
else:
|
||||
raise NotImplementedError
|
||||
|
||||
return output
|
||||
|
||||
|
||||
def apply_phase_retardance(probe, phase_shift, multiple_modes=True):
|
||||
"""
|
||||
Shifts the y-component of the field wrt the x-component by a given phase shift
|
||||
|
||||
Parameters:
|
||||
----------
|
||||
probe: t.Tensor
|
||||
A (...)x2x1xMxL tensor representing the probe
|
||||
phase_shift: float
|
||||
phase shift in degrees
|
||||
|
||||
Returns:
|
||||
--------
|
||||
probe: t.Tensor
|
||||
(...)x2x1xMxL
|
||||
"""
|
||||
theta = t.as_tensor(phase_shift, dtype=t.float32)
|
||||
theta = t.deg2rad(theta)
|
||||
probe = probe.to(dtype=t.cfloat)
|
||||
jones_matrix = t.tensor([[1, 0], [0, t.exp(phase_shift)]]).to(dtype=t.cfloat)
|
||||
polarized = apply_jones_matrix(probe, jones_matrix, multiple_modes=multiple_modes)
|
||||
|
||||
return polarized
|
||||
|
||||
def apply_circular_polarizer(probe, left_polarized=True, multiple_modes=True):
|
||||
"""
|
||||
Applies a circular polarizer to the probe
|
||||
|
||||
Parameters:
|
||||
----------
|
||||
probe: t.Tensor
|
||||
A (...)x2xMxL tensor representing the probe
|
||||
left_polarizd: bool
|
||||
True for the left-polarization, False for the right
|
||||
|
||||
Returns:
|
||||
--------
|
||||
circularly polarized probe: t.Tensor
|
||||
(...)x2xMxL
|
||||
"""
|
||||
probe = probe.to(dtype=t.cfloat)
|
||||
if left_polarized:
|
||||
jones_matrix = (1/2 * t.tensor([[1, -1j], [1j, 1]])).to(dtype=t.cfloat)
|
||||
else:
|
||||
jones_matrix = 1/2 * t.tensor([[1, 1j], [-1j, 1]]).to(dtype=t.cfloat)
|
||||
polarized = apply_jones_matrix(probe, jones_matrix, multiple_modes=multiple_modes)
|
||||
return polarized
|
||||
|
||||
def apply_quarter_wave_plate(probe, fast_axis_angle, multiple_modes=True):
|
||||
"""
|
||||
Parameters:
|
||||
----------
|
||||
probe: t.Tensor
|
||||
A (...)x2x1xMxL tensor representing the probe, MxL - the size of the probe
|
||||
fast_axis_angle: float
|
||||
The angle between the fast-axis of the polarizer and the horizontal axis
|
||||
|
||||
Returns:
|
||||
--------
|
||||
polarized probe: t.Tensor
|
||||
(...)x2x1xMxL
|
||||
"""
|
||||
probe = probe.to(dtype=t.cfloat)
|
||||
theta = math.radians(fast_axis_angle)
|
||||
exponent = t.exp(-1j * math.pi / 4 * t.ones(2, 2))
|
||||
jones_matrix = exponent* t.tensor([[(cos(theta))**2 + 1j * (sin(theta))**2, (1 - 1j) * sin(theta) * cos(theta)], [(1 - 1j) * sin(theta) * cos(theta), (sin(theta))**2 + 1j * (cos(theta))**2]]).to(dtype=t.cfloat)
|
||||
out = apply_jones_matrix(probe, jones_matrix, multiple_modes=multiple_modes)
|
||||
|
||||
return out
|
||||
|
||||
def apply_half_wave_plate(probe, fast_axis_angle, multiple_modes=True):
|
||||
"""
|
||||
Parameters:
|
||||
----------
|
||||
probe: t.Tensor
|
||||
A (...)x2x1xMxL tensor representing the probe, MxL - the size of the probe
|
||||
fast_axis_angle: float
|
||||
The angle between the fast-axis of the polarizer and the horizontal axis
|
||||
|
||||
Returns:
|
||||
--------
|
||||
polarized probe: t.Tensor
|
||||
(...)x2x1xMxL
|
||||
"""
|
||||
probe = probe.to(dtype=t.cfloat)
|
||||
theta = math.radians(fast_axis_angle)
|
||||
exponent = t.exp(-1j * math.pi / 2 * t.ones(2, 2))
|
||||
jones_matrix = exponent * t.tensor([[(cos(theta))**2 - (sin(theta))**2, 2 * sin(theta) * cos(theta)], [2 * sin(theta) * cos(theta), (sin(theta))**2 - (cos(theta))**2]]).to(dtype=t.cfloat)
|
||||
out = apply_jones_matrix(probe, jones_matrix, multiple_modes=multiple_modes)
|
||||
|
||||
return out
|
||||
|
||||
def generate_birefringent_obj(fast_axis=90, phase_ret=10, atten_fast=1, atten_ret=1, global_phase=0):
|
||||
def to_rad(angle):
|
||||
angle = t.as_tensor(angle, dtype=t.float32)
|
||||
angle = t.deg2rad(angle)
|
||||
return angle
|
||||
|
||||
fast_axis = to_rad(fast_axis)
|
||||
phase_ret = to_rad(phase_ret)
|
||||
global_phase = to_rad(global_phase)
|
||||
|
||||
def coord_rot(angle):
|
||||
a = t.stack((t.cos(angle), t.sin(angle)), dim=-1)
|
||||
b = t.stack((-t.sin(angle), t.cos(angle)), dim=-1)
|
||||
return t.stack((a, b), dim=-2).to(dtype=t.cfloat)
|
||||
|
||||
r1 = coord_rot(-fast_axis)
|
||||
r2 = coord_rot(fast_axis)
|
||||
p = t.exp(global_phase * 1j) * t.as_tensor([[atten_fast, 0], [0, atten_ret * t.exp(phase_ret*1j)]], dtype=t.cfloat)
|
||||
return t.matmul(r1, t.matmul(p, r2))
|
||||
@@ -0,0 +1 @@
|
||||
from CDTools.tools.propagators.propagators import *
|
||||
@@ -0,0 +1,646 @@
|
||||
"""This module contains various propagators for light fields
|
||||
|
||||
All the functions here are designed for use in an automatic differentiation
|
||||
ptychography model. Each function implements a different propagator.
|
||||
"""
|
||||
|
||||
import torch as t
|
||||
from torch.nn.functional import grid_sample
|
||||
from scipy import fftpack
|
||||
import numpy as np
|
||||
from matplotlib import pyplot as plt
|
||||
|
||||
__all__ = ['far_field', 'near_field',
|
||||
'generate_angular_spectrum_propagator',
|
||||
'inverse_far_field', 'inverse_near_field',
|
||||
'generate_high_NA_k_intensity_map',
|
||||
'high_NA_far_field',
|
||||
'generate_generalized_angular_spectrum_propagator']
|
||||
|
||||
def far_field(wavefront):
|
||||
"""Implements a far-field propagator in torch
|
||||
|
||||
This accepts a torch tensor, where the last dimension
|
||||
represents the real and imaginary components of the wavefield,
|
||||
and returns the far-field propagated version of it assuming it matches the
|
||||
detector dimensions. It assumes that the
|
||||
propagation is purely far-field, without checking that the geometry
|
||||
is consistent with that assumption.
|
||||
|
||||
|
||||
It also assumes that the real space wavefront is stored in an array
|
||||
[i,j] where i corresponds to the y-axis and j corresponds to the
|
||||
x-axis, with the origin following the CS standard of being in the
|
||||
upper right. The zero frequency component of the propagated wavefield is
|
||||
shifted to the center of the array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
wavefront : torch.Tensor
|
||||
The JxNxMx2 stack of complex wavefronts to be propagated
|
||||
|
||||
Returns
|
||||
-------
|
||||
propagated : torch.Tensor
|
||||
The JxNxMx2 propagated wavefield
|
||||
"""
|
||||
|
||||
shifted = t.fft.ifftshift(wavefront, dim=(-1,-2))
|
||||
propagated = t.fft.fft2(shifted, norm='ortho')
|
||||
return t.fft.fftshift(propagated, dim=(-1,-2))
|
||||
|
||||
|
||||
def inverse_far_field(wavefront):
|
||||
"""Implements the inverse of the far-field propagator in torch
|
||||
|
||||
This accepts a torch tensor, where the last dimension
|
||||
represents the real and imaginary components of the propagated wavefield,
|
||||
and returns the un-propagated array.
|
||||
|
||||
It assumes that the real space wavefront is stored in an array
|
||||
[i,j] where i corresponds to the y-axis and j corresponds to the
|
||||
x-axis, with the origin following the CS standard of being in the
|
||||
upper right. The zero frequency component of the propagated wavefield is
|
||||
assumed to be the center of the array.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
wavefront : torch.Tensor
|
||||
The JxNxMx2 stack of complex wavefronts propagated to the far-field
|
||||
|
||||
Returns
|
||||
-------
|
||||
propagated : torch.Tensor
|
||||
The JxNxMx2 exit wavefield
|
||||
"""
|
||||
shifted = t.fft.ifftshift(wavefront, dim=(-1,-2))
|
||||
propagated = t.fft.ifft2(shifted, norm='ortho')
|
||||
return t.fft.fftshift(propagated, dim=(-1,-2))
|
||||
|
||||
|
||||
def generate_high_NA_k_intensity_map(sample_basis, det_basis,det_shape,distance, wavelength, *args, lens=False, **kwargs):
|
||||
"""Generates k-space and intensity maps to allow for high-NA far-field propagation of light
|
||||
|
||||
At high numerical apertures or for very tilted samples, the simple
|
||||
linear map between location on the detector and location in k-space
|
||||
starts to break down. In addition, at angles above roughly 15 degrees,
|
||||
a correction is needed to account for the decreasing solid angle
|
||||
intersected by each pixel on the detector.
|
||||
|
||||
This function generates a map which can be used to apply both corrections
|
||||
via the high_NA_far_field propagator. The k-map which is output is
|
||||
defined as a map between pixel location on the detector and locations
|
||||
in the output of the standard, low-NA far-field propagated wavefield.
|
||||
The output coordinate system is defined to run from -1 to 1 in both
|
||||
directions - this allows for compatibility with pytorch's grid_sample
|
||||
function. Some detector pixels may be mapped to values outside the
|
||||
rangel [-1,1], depending on the respective sample and detector geometries.
|
||||
This is most likely to be the case if the major correction is due to a
|
||||
tilted sample.
|
||||
|
||||
The intensity map is simply an object, the shape of the detector, which
|
||||
encodes intensity corrections between 0 and 1 per pixel.
|
||||
|
||||
If the optional "lens" parameter is set to True, the intensity map will
|
||||
be set to a uniform map, and the distortion of Fourier space due to the
|
||||
flat nature of the detector (that is, the portion of the distortion
|
||||
that exists even if the sample is not tilted) will be disabled. This is
|
||||
to account for the fact that a good, infinity-conjugate imaging lens
|
||||
will do it's best to correct for these abberations in the lens. Of course,
|
||||
the lens will not be perfect, but in such a case it is a better
|
||||
approximation to assume that the lens is perfect than to assume that it
|
||||
is not there at all.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
sample_basis: array
|
||||
The 3x2 sample basis, in real space
|
||||
det_basis: array
|
||||
The 3x2 detector basis, in real space
|
||||
det_shape: array
|
||||
The length-2 shape of the detector array, (N,M)
|
||||
distance: float
|
||||
The sample-to-detector distance
|
||||
wavelength: float
|
||||
The wavelength of light being propagated
|
||||
lens: bool
|
||||
Whether the diffraction pattern is formed by a lens or not.
|
||||
|
||||
Returns
|
||||
-------
|
||||
k_map : torch.Tensor
|
||||
An NxMx2 tensor mapping detector pixels to locations in the low-NA propagated wavefield
|
||||
intensity_map : torch.Tensor
|
||||
An NxM tensor encoding the high-NA intensity correction
|
||||
"""
|
||||
|
||||
# First we convert things to numpy
|
||||
try:
|
||||
sample_basis = sample_basis.detach().cpu().numpy()
|
||||
except:
|
||||
pass
|
||||
|
||||
try:
|
||||
det_basis = det_basis.detach().cpu().numpy()
|
||||
except:
|
||||
pass
|
||||
|
||||
det_shape = np.array(tuple(det_shape))
|
||||
|
||||
try:
|
||||
distance = distance.detach().cpu().numpy()[0]
|
||||
except:
|
||||
pass
|
||||
|
||||
try:
|
||||
wavelength = wavelength.detach().cpu().numpy()[0]
|
||||
except:
|
||||
pass
|
||||
|
||||
# The next order of business is to calculate the k values associated with
|
||||
# each pixel.
|
||||
|
||||
i_arr = np.arange(det_shape[0])
|
||||
i_arr = i_arr - np.mean(i_arr)
|
||||
j_arr = np.arange(det_shape[1])
|
||||
j_arr = j_arr - np.mean(j_arr)
|
||||
Is, Js = np.meshgrid(i_arr,j_arr,indexing='ij')
|
||||
samp_det_vec = np.cross(det_basis[:,0],det_basis[:,1])
|
||||
samp_det_vec *= distance / np.linalg.norm(samp_det_vec)
|
||||
|
||||
# This could potentially correct for a mistake in the implied
|
||||
# propagation direction (e.g. choosing e^ikx instead of e^-ikx)
|
||||
# This appears to be correct, based on empirical evidence from
|
||||
# a grazing incidence reflection experiment at 10 degrees
|
||||
# on the optical table
|
||||
samp_det_vec *= -1
|
||||
|
||||
if lens == False:
|
||||
# This correctly reproduces the sample-to-each-pixel vectors
|
||||
# in the case where the diffraction pattern is actually formed
|
||||
# by Fraunhoffer diffraction
|
||||
Rs = np.tensordot(det_basis,np.stack([Is,Js]),axes=1) \
|
||||
+ samp_det_vec[:,None,None]
|
||||
else:
|
||||
# This forms a distorted set of vectors designed to produce the
|
||||
# correct Fourier space map in the case where an imaging lens is
|
||||
# used in the 2f geometry. One should not read too much meaning
|
||||
# into these vectors, they are simply set up to produce the
|
||||
# correct final K-map
|
||||
Rs = np.tensordot(det_basis,np.stack([Is,Js]),axes=1)#
|
||||
Rs += (samp_det_vec / np.linalg.norm(samp_det_vec))[:,None,None] * \
|
||||
np.sqrt(np.sum((samp_det_vec)**2)-np.sum(Rs**2,axis=0))[None,:,:]
|
||||
|
||||
k0 = 2*np.pi/wavelength
|
||||
|
||||
Ks = k0 * Rs / np.linalg.norm(Rs, axis=0)
|
||||
|
||||
# My attempt at seeing what happens if I flip the Ks
|
||||
#Ks *= -1
|
||||
|
||||
# This is the cosine of the angle with the detector normal
|
||||
intensity_map = np.tensordot(samp_det_vec/(k0*distance),Ks,axes=1)
|
||||
if lens:
|
||||
# Set the intensity map to be uniform if a lens is being used
|
||||
intensity_map = np.ones_like(intensity_map)
|
||||
|
||||
intensity_map = t.Tensor(intensity_map).to(*args, **kwargs)
|
||||
|
||||
|
||||
# This accounts for the implied phase ramp along the exit wave direction
|
||||
# In other words, it prevents the diffraction pattern from sliding off the
|
||||
# detector when the sample is tilted but represented by an object with
|
||||
# uniform phase.
|
||||
Ks -= k0 * samp_det_vec[:,None,None] / distance
|
||||
|
||||
# A potential alternative when Ks are flipped
|
||||
#Ks += k0 * samp_det_vec[:,None,None] / distance
|
||||
|
||||
|
||||
# Now we move on to finding the conversion into k-space
|
||||
# for the sample grid. It turns out we can do this by multiplying
|
||||
# them with the real space basis (dual of the reciprocal space
|
||||
# basis is the real space basis). In fact, because we want to return
|
||||
# values scaled to the overall size of the k-space window, we don't
|
||||
# even need the shape of the sample array
|
||||
|
||||
k_map = np.tensordot(2*sample_basis.transpose()[::-1,:] / (2*np.pi),Ks,axes=1)
|
||||
k_map = t.Tensor(np.moveaxis(k_map,0,2)).to(*args, **kwargs)
|
||||
|
||||
# Potentially we need a correction to account for the discrete nature
|
||||
# of the FFT
|
||||
|
||||
# And finally, we need to convert the results to pytorch
|
||||
|
||||
return k_map, intensity_map
|
||||
|
||||
|
||||
|
||||
|
||||
def high_NA_far_field(wavefront, k_map, intensity_map=None):
|
||||
"""Performs a far-field propagation step including a correction for high-NA scenarios
|
||||
|
||||
Two major corrections need to be performed when propagating light fields
|
||||
into the far field at high numerical aperture or when the sample is
|
||||
tilted as compared to the detector. The first correction is a deviation
|
||||
from the linear relationship between detector position and spatial
|
||||
frequency in the near field. This is accounted for with the k_map
|
||||
argument, as generated by the generate_high_NA_k_intensity_map
|
||||
function.
|
||||
|
||||
The second correction is the change in the solid angle which each pixel
|
||||
subtends at high NA. This is accounted for with an optional intensity
|
||||
map. This is kept optional because some detectors - specifically, those
|
||||
for penetrating radiation - may either not need a correction or need
|
||||
a different correction due to the volumetric nature of the pixels.
|
||||
|
||||
If the k-map maps any pixels on the detector to pixels outside of the
|
||||
k-space range of the wavefront, these will be set to zero. This is in
|
||||
keeping with the typical assumption that the sample is band-limited to
|
||||
the Nyquist frequency for the array on which it is sampled.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
wavefront : torch.Tensor
|
||||
The JxNxMx2 stack of complex wavefronts propagated to the far-field
|
||||
k_map : torch.Tensor
|
||||
The NxMx2 map accounting for high NA distortion, as generated by generate_high_NA_k_intensity_map
|
||||
intensity_map : torch.Tensor
|
||||
The optional NxM tensor accounting for the intensity variation across the detector
|
||||
|
||||
|
||||
Returns
|
||||
-------
|
||||
propagated : torch.Tensor
|
||||
The JxNxMx2 exit wavefield
|
||||
|
||||
|
||||
"""
|
||||
low_NA_wavefield = far_field(wavefront)
|
||||
# I'm going to need to separately interpolate the real and complex parts
|
||||
# This can be done
|
||||
|
||||
k_map = k_map[None,:,:,:]
|
||||
# Will only work for a 4D wavefile stack.
|
||||
#plt.figure()
|
||||
#plt.pcolormesh(k_map[0,:,:,0].cpu().numpy(),k_map[0,:,:,1].cpu().numpy(),
|
||||
# np.ones_like(k_map[0,:-1,:-1,0].cpu().numpy()))
|
||||
#plt.show()
|
||||
def process_wavefield_stack(low_NA_wavefield):
|
||||
# grid_sample doesn't work on complex-valued wavefields
|
||||
real_output = grid_sample(low_NA_wavefield[None,:,:,:].real,k_map,mode='bilinear',padding_mode='zeros', align_corners=False)
|
||||
imag_output = grid_sample(low_NA_wavefield[None,:,:,:].imag,k_map,mode='bilinear',padding_mode='zeros', align_corners=False)
|
||||
|
||||
result = real_output[0,:,:,:] + 1j * imag_output[0,:,:,:]
|
||||
|
||||
if intensity_map is not None:
|
||||
result = result * intensity_map[None,:,:]
|
||||
|
||||
return result
|
||||
|
||||
original_dim = wavefront.dim()
|
||||
if original_dim == 2:
|
||||
result = process_wavefield_stack(low_NA_wavefield[None,:,:])
|
||||
return result[0,:,:]
|
||||
if original_dim == 3:
|
||||
result = process_wavefield_stack(low_NA_wavefield)
|
||||
return result
|
||||
if original_dim == 4:
|
||||
result = []
|
||||
for i in range(low_NA_wavefield.size()[0]):
|
||||
result.append(process_wavefield_stack(low_NA_wavefield[i,:,:,:]))
|
||||
return t.stack(result)
|
||||
else:
|
||||
raise IndexError('Wavefield had incorrect number of dimensions')
|
||||
|
||||
|
||||
|
||||
def generate_angular_spectrum_propagator(shape, spacing, wavelength, z, *args, remove_z_phase=False, bandlimit=None, **kwargs):
|
||||
"""Generates an angular-spectrum based near-field propagator from experimental quantities
|
||||
|
||||
This function generates an angular-spectrum based near field
|
||||
propagator that will work on torch Tensors. The function is structured
|
||||
this way - to generate the propagator first - because the
|
||||
generation of the propagation mask is a bit expensive and if this
|
||||
propagator is used in a reconstruction program, then it will be best
|
||||
to calculate this mask once and reuse it.
|
||||
|
||||
Formally, this propagator is the the fourier transform of the convolution
|
||||
kernel for light propagation in free space
|
||||
|
||||
If the optional bandlimit parameter is set, the propagator will be set
|
||||
to zero beyond an explicit bandlimiting frequency. This is helpful if the
|
||||
propagator will be used in a repeated multiply/propagate framework such
|
||||
as a multislice algorithm, where it helps to prevent aliasing.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
shape : array
|
||||
The shape of the arrays to be propagated
|
||||
spacing : array
|
||||
The pixel size in each dimension of the arrays to be propagated
|
||||
wavelength : float
|
||||
The wavelength of light to simulate propagation of
|
||||
z : float
|
||||
The distance to simulate propagation over
|
||||
remove_z_phase : bool
|
||||
Default False, whether to remove the dominant z-direction phase dependence
|
||||
bandlimit : float
|
||||
Optional, a fraction of the full detector radius beyond which to set the propagator to zero.
|
||||
|
||||
Returns
|
||||
-------
|
||||
propagator : torch.Tensor
|
||||
A phase mask which accounts for the phase change that each plane wave will undergo.
|
||||
"""
|
||||
|
||||
# Internally, the generalized propagation function is used, so we start
|
||||
# by creating an appropriate basis
|
||||
# This creates a real-valued tensor which matches the kind of complex
|
||||
# number dtype requested in **kwargs
|
||||
if 'dtype' in kwargs:
|
||||
basis = t.real(t.zeros([3,2], **kwargs))
|
||||
else:
|
||||
basis = t.zeros([3,2], dtype=t.float32)
|
||||
spacing = t.as_tensor(spacing, dtype=basis.dtype)
|
||||
|
||||
basis[1,0] = -spacing[0]
|
||||
basis[0,1] = -spacing[1]
|
||||
# And similarly, the offset is just z along the z direction
|
||||
#offset = t.tensor([0,0,z], dtype=basis.dtype)
|
||||
offset = t.zeros(3, dtype=basis.dtype)
|
||||
offset[2] = z
|
||||
|
||||
# And we call the generalized function!
|
||||
propagator = generate_generalized_angular_spectrum_propagator(shape, basis,
|
||||
wavelength, offset,
|
||||
propagate_along_offset=remove_z_phase, **kwargs)
|
||||
if z < 0:
|
||||
propagator = t.conj(propagator)
|
||||
|
||||
|
||||
# Bandlimiting is not implemented in the generalized function, because it
|
||||
# has a less clear meaning in that setting, so we apply it here instead
|
||||
if bandlimit is not None:
|
||||
# No need to multiply by 2pi
|
||||
ki = 2 * np.pi * t.fft.fftfreq(shape[0],spacing[0])
|
||||
kj = 2 * np.pi * t.fft.fftfreq(shape[1],spacing[1])
|
||||
Ki, Kj = t.meshgrid(ki,kj, indexing='ij')
|
||||
min_radius = min(t.max(ki),t.max(kj))
|
||||
Rs = t.sqrt((Ki/t.max(ki))**2 + (Kj/t.max(kj))**2)
|
||||
propagator = propagator * (Rs < bandlimit)
|
||||
|
||||
return propagator
|
||||
|
||||
|
||||
|
||||
def generate_generalized_angular_spectrum_propagator(shape, basis, wavelength, offset_vector, *args, propagation_vector=None, propagate_along_offset=False, **kwargs):
|
||||
"""Generates an angular-spectrum based near-field propagator from experimental quantities
|
||||
|
||||
This function generates an angular-spectrum based near field
|
||||
propagator that will work on torch Tensors. The function is structured
|
||||
this way - to generate the propagator first - because the
|
||||
generation of the propagation mask is a bit expensive and if this
|
||||
propagator is used in a reconstruction program, it will be best
|
||||
to calculate this mask once and then reuse it it.
|
||||
|
||||
Formally, this propagator is the fourier transform of the convolution
|
||||
kernel for light propagation in free space. It will map a light field
|
||||
at an input plane, with the size and shape defined by the shape and basis
|
||||
inputs, and map it to a plane of the same size and shape offset by the
|
||||
offset vector. It is designed to work on any wavefield defined on an
|
||||
array of parallelograms.
|
||||
|
||||
|
||||
In addition, if the propagation_vector is set, there is an assumed
|
||||
phase ramp applied to the wavefield before propagation, defined such
|
||||
that a feature with uniform phase will propagate along the direction of
|
||||
the propagation vector. This will also remove the phase variation along
|
||||
the propagation direction, because it makes the most physical sense to
|
||||
regard this choice as removing the dominant phase variation in 3D, allowing
|
||||
for the generation of a smoothly varying wavefield over 3D volumes.
|
||||
This decision provides the best numerical stability and allows for the
|
||||
simple setup of light fields copropagating with the coordinate system.
|
||||
|
||||
If the propagate_along_offset option is set to True, then the propagation
|
||||
vector will be set equal to the offset vector. This overrides the
|
||||
propagation_vector option
|
||||
|
||||
Note that, unlike in the case of the simple angular spectrum propagator,
|
||||
the direction of "forward propagation" is defined by the propagation
|
||||
vector, or (if the propagation vector is not defined), the offset
|
||||
vector. Therefore, in the simple case of a perpendicular offset,
|
||||
there will be no difference between using an offset vector or the
|
||||
negative of the offset vector. This is because, for the light
|
||||
propagation problem to be well posed, the assumption must be made that
|
||||
light only passes through the plane of the known wavefield in one
|
||||
direction. We always assume that light passes through the initial plane
|
||||
travelling in the direction of the final plane.
|
||||
|
||||
Practically, if one wants to simulate inverse propagation, there are
|
||||
two possible approaches. First, one can use the inverse_near_field
|
||||
function, which simulates the inverse propagation problem and therefore
|
||||
will naturally simulate propagation in the opposite direction. Second,
|
||||
one can explicitly include a propagation_vector argument, in the direction
|
||||
opposite to the offset vector. Note for both cases that this function
|
||||
will only return propagators which suppress evanescent waves. Thus,
|
||||
propagating forward and then backward by either of these two methods
|
||||
will lead to a supression of evanescant waves. If you need a propagator
|
||||
that will cause evanescent waves to undergo exponential growth, good
|
||||
for you, but this function will not provide it for you.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
shape : array
|
||||
The shape of the arrays to be propagated
|
||||
basis : array
|
||||
The (2x3) set of basis vectors describing the array to be propagated
|
||||
wavelength : float
|
||||
The wavelength of light to simulate propagation of
|
||||
offset_vector : array
|
||||
The displacement to propagate the wavefield along.
|
||||
propagation_vector : array
|
||||
The vector along which to include an implied phase ramp to propagate uniform phase features along, if set
|
||||
propagate_along_offset : bool
|
||||
Overrides propagation_vector, sets the propagation vector to equal the offset vector if set.
|
||||
|
||||
Returns
|
||||
-------
|
||||
propagator : torch.Tensor
|
||||
A phase mask which accounts for the phase change that each plane wave will undergo.
|
||||
"""
|
||||
|
||||
# make sure everything is in pytorch, and set the propagation vector
|
||||
# appropriately if propagate_along_offset is chosen
|
||||
basis = t.as_tensor(basis)
|
||||
offset_vector = t.as_tensor(offset_vector, dtype=basis.dtype)
|
||||
|
||||
if propagate_along_offset:
|
||||
propagation_vector = offset_vector
|
||||
|
||||
if propagation_vector is not None:
|
||||
propagation_vector = t.as_tensor(propagation_vector, dtype=basis.dtype)
|
||||
|
||||
#
|
||||
# In this section, we calculate the wavevectors associated with each
|
||||
# pixel in Fourier space. This is the meat of the function
|
||||
#
|
||||
|
||||
# First we calculate a dual basis for the real space grid
|
||||
inv_basis = t.linalg.pinv(basis).transpose(0,1)
|
||||
|
||||
# Then we calculate the frequencies in (i,j) space
|
||||
ki = 2 * np.pi * t.fft.fftfreq(shape[0], dtype=inv_basis.dtype)
|
||||
kj = 2 * np.pi * t.fft.fftfreq(shape[1], dtype=inv_basis.dtype)
|
||||
K_ij = t.stack(t.meshgrid(ki,kj, indexing='ij'))
|
||||
|
||||
# Now we convert these to frequencies in reciprocal space
|
||||
# These frequencies span the 2D plane of the input wavefield,
|
||||
# hence K_ip for "in-plane"
|
||||
K_ip = t.tensordot(inv_basis, K_ij, dims=1)
|
||||
|
||||
|
||||
# Now, we need to generate the out-of-plane direction, so we can
|
||||
# expand these Ks to the full Ks in 3D reciprocal space.
|
||||
|
||||
# This is broken down into 2 steps to avoid floating point underflow
|
||||
# which was a real problem that showed up for electron ptycho
|
||||
b1_dir = basis[:,0] / t.linalg.norm(basis[:,0])
|
||||
b2_dir = basis[:,1] / t.linalg.norm(basis[:,1])
|
||||
perpendicular_dir = t.cross(b1_dir,b2_dir)
|
||||
# Note that we cannot use in-place operations if we want to be able to
|
||||
# use automatic differentiation successfully
|
||||
perpendicular_dir = perpendicular_dir / t.linalg.norm(perpendicular_dir)
|
||||
|
||||
# We set the sign of the propagation direction appropriately
|
||||
if propagation_vector is not None:
|
||||
perpendicular_dir = perpendicular_dir \
|
||||
* t.sign(t.dot(perpendicular_dir,propagation_vector))
|
||||
else:
|
||||
pass
|
||||
perpendicular_dir = perpendicular_dir * \
|
||||
t.sign(t.dot(perpendicular_dir,offset_vector))
|
||||
|
||||
# Then, if we have a propagation vector, we shift the in-plane
|
||||
# components of all the pixels to be centered around the in-plane
|
||||
# component of the propagation vector.
|
||||
if propagation_vector is not None:
|
||||
prop_dir = (propagation_vector /
|
||||
t.linalg.norm(propagation_vector))
|
||||
K_0 = 2*np.pi / wavelength * prop_dir
|
||||
K_0_ip = K_0 - t.dot(perpendicular_dir,K_0) * perpendicular_dir
|
||||
K_ip += K_0_ip[:,None,None]
|
||||
else:
|
||||
K_0 = t.zeros_like(offset_vector)
|
||||
|
||||
# Now, we have accurate in-plane values for K, so we can calculate the
|
||||
# out-of-plane part. We start by calculating it's squared magnitude
|
||||
K_oop_squared = (2*np.pi/wavelength)**2 - t.linalg.norm(K_ip,dim=0)**2
|
||||
|
||||
# Then, we take the square root and assign it the appropriate direction,
|
||||
# adding to get the full 3D wavevectors. Note that we convert to complex
|
||||
# before the square root to appropriately map negative numbers to
|
||||
# complex frequencies
|
||||
K = K_ip + perpendicular_dir[:,None,None] \
|
||||
* t.sqrt(t.complex(K_oop_squared,t.zeros_like(K_oop_squared)))
|
||||
|
||||
#
|
||||
# In this section, we take the inner product of the calcualted
|
||||
# wavevectors with the offset vector, to get the phase shift
|
||||
# experienced by each plane wave.
|
||||
#
|
||||
|
||||
# We need to convert to complex because K is complex
|
||||
offset_vector = t.complex(offset_vector,t.zeros_like(offset_vector))
|
||||
|
||||
# We then subtract off K_0, essentially setting the phase offset
|
||||
# experienced by K_0 to 0. K_0 will already have been set to 0 if
|
||||
# there was no propagation vector set.
|
||||
K_m_K_0 = K - K_0[:,None,None]
|
||||
# We actually calculate the phase mask
|
||||
phase_mask = t.tensordot(offset_vector,K_m_K_0, dims=1)
|
||||
|
||||
# And we take the conjugate if needed, which makes sure that the
|
||||
# imaginary part is always positive (supressing evanescent waves)
|
||||
if propagation_vector is not None \
|
||||
and t.sign(t.dot(propagation_vector,offset_vector.real)) == -1:
|
||||
phase_mask = t.conj(phase_mask)
|
||||
|
||||
# We return the final mask, in the form asked for!
|
||||
return t.exp(1j*phase_mask).to(*args,**kwargs)
|
||||
|
||||
|
||||
def near_field(wavefront, angular_spectrum_propagator):
|
||||
""" Propagates a wavefront via the angular spectrum method
|
||||
|
||||
This function accepts an 3D torch tensor, where the last dimension
|
||||
represents the real and imaginary components of the wavefield, and
|
||||
returns the near-field propagated version of it. It does this
|
||||
using the supplied angular spectrum propagator, which is a premade
|
||||
phase mask representing the Fourier transform of the kernel for
|
||||
light propagation in the desired geometry.
|
||||
|
||||
|
||||
Parameters
|
||||
----------
|
||||
wavefront : torch.Tensor
|
||||
The (Leading Dims)xNxM stack of complex wavefronts to be propagated
|
||||
angular_spectrum_propagator : torch.Tensor
|
||||
The NxM phase mask to be applied during propagation
|
||||
|
||||
Returns
|
||||
-------
|
||||
propagated : torch.Tensor
|
||||
The propagated wavefront
|
||||
"""
|
||||
return t.fft.ifft2(angular_spectrum_propagator * t.fft.fft2(wavefront))
|
||||
|
||||
|
||||
|
||||
def inverse_near_field(wavefront, angular_spectrum_propagator):
|
||||
""" Inverse propagates a wavefront via the angular spectrum method
|
||||
|
||||
This function accepts an 3D torch tensor, where the last dimension
|
||||
represents the real and imaginary components of the wavefield, and
|
||||
returns the near-field propagated version of it. It does this
|
||||
using the supplied angular spectrum propagator, which is a premade
|
||||
phase mask.
|
||||
|
||||
It propagates the wave using the complex conjugate of the supplied
|
||||
phase mask. This corresponds to propagation backward across the original
|
||||
propagation region - however, the treatment of evanescent waves is such
|
||||
that evanescent waves will decay both during the forward propagation and
|
||||
inverse propagation. This is done for reasons of numerical stability,
|
||||
as the choice to magnify evanescent waves during the inverse propagation
|
||||
process will quickly lead to magnification of any small amount of noise at
|
||||
frequencies larger than k_0, and in most typical situations will even
|
||||
lead to overflow of the floating point range. If evanescent waves need
|
||||
to be treated appropriately for any reason, it is recommended to use the
|
||||
"magnify_evanescent" option in the appropriate helper function used to
|
||||
generate the propagation phase mask. In this case, evanescent waves will
|
||||
be magnified both when used with the forward and inverse near field
|
||||
functions
|
||||
|
||||
|
||||
Parameters
|
||||
----------
|
||||
wavefront : torch.Tensor
|
||||
The JxNxMx2 stack of complex wavefronts to be propagated
|
||||
angular_spectrum_propagator : torch.Tensor
|
||||
The NxM phase mask to be applied during propagation
|
||||
|
||||
Returns
|
||||
-------
|
||||
propagated : torch.Tensor
|
||||
The inverse propagated wavefront
|
||||
"""
|
||||
return t.fft.ifft2(t.fft.fft2(wavefront)
|
||||
* t.conj(angular_spectrum_propagator))
|
||||
|
||||
|
||||
|
||||
# I think it would be worthwhile to implement an FFT-DI based strategy as
|
||||
# well, especially for probe initialization where the propagation distance
|
||||
# can be large relative to what the angular spectrum method can reliably handle
|
||||
|
||||
|
||||
Reference in new issue
Block a user