def test_mask():
length = 100
ramps = [np.linspace(0, 4 * np.pi, length),
np.linspace(0, 8 * np.pi, length),
np.linspace(0, 6 * np.pi, length)]
image = np.vstack(ramps)
mask_1d = np.ones((length,), dtype=np.bool)
mask_1d[0] = mask_1d[-1] = False
for i in range(len(ramps)):
# mask all ramps but the i'th one
mask = np.zeros(image.shape, dtype=np.bool)
mask |= mask_1d.reshape(1, -1)
mask[i, :] = False # unmask i'th ramp
image_wrapped = np.ma.array(np.angle(np.exp(1j * image)), mask=mask)
image_unwrapped = unwrap_phase(image_wrapped)
image_unwrapped -= image_unwrapped[0, 0] # remove phase shift
# The end of the unwrapped array should have value equal to the
# endpoint of the unmasked ramp
assert_array_almost_equal_nulp(image_unwrapped[:, -1], image[i, -1])
assert_(np.ma.isMaskedArray(image_unwrapped))
# Same tests, but forcing use of the 3D unwrapper by reshaping
with expected_warnings(['length 1 dimension']):
shape = (1,) + image_wrapped.shape
image_wrapped_3d = image_wrapped.reshape(shape)
image_unwrapped_3d = unwrap_phase(image_wrapped_3d)
# remove phase shift
image_unwrapped_3d -= image_unwrapped_3d[0, 0, 0]
assert_array_almost_equal_nulp(image_unwrapped_3d[:, :, -1],
image[i, -1])
def check_wrap_around(ndim, axis):
# create a ramp, but with the last pixel along axis equalling the first
elements = 100
ramp = np.linspace(0, 12 * np.pi, elements)
ramp[-1] = ramp[0]
image = ramp.reshape(tuple([elements if n == axis else 1
for n in range(ndim)]))
image_wrapped = np.angle(np.exp(1j * image))
index_first = tuple([0] * ndim)
index_last = tuple([-1 if n == axis else 0 for n in range(ndim)])
# unwrap the image without wrap around
with warnings.catch_warnings():
# We do not want warnings about length 1 dimensions
warnings.simplefilter("ignore")
image_unwrap_no_wrap_around = unwrap_phase(image_wrapped, seed=0)
print('endpoints without wrap_around:',
image_unwrap_no_wrap_around[index_first],
image_unwrap_no_wrap_around[index_last])
# without wrap around, the endpoints of the image should differ
assert_(abs(image_unwrap_no_wrap_around[index_first] -
image_unwrap_no_wrap_around[index_last]) > np.pi)
# unwrap the image with wrap around
wrap_around = [n == axis for n in range(ndim)]
with warnings.catch_warnings():
# We do not want warnings about length 1 dimensions
warnings.simplefilter("ignore")
image_unwrap_wrap_around = unwrap_phase(image_wrapped, wrap_around,
seed=0)
print('endpoints with wrap_around:',
image_unwrap_wrap_around[index_first],
image_unwrap_wrap_around[index_last])
# with wrap around, the endpoints of the image should be equal
assert_almost_equal(image_unwrap_wrap_around[index_first],
image_unwrap_wrap_around[index_last])
def test_mask():
length = 100
ramps = [
np.linspace(0, 4 * np.pi, length),
np.linspace(0, 8 * np.pi, length),
np.linspace(0, 6 * np.pi, length)
]
image = np.vstack(ramps)
mask_1d = np.ones((length, ), dtype=np.bool)
mask_1d[0] = mask_1d[-1] = False
for i in range(len(ramps)):
# mask all ramps but the i'th one
mask = np.zeros(image.shape, dtype=np.bool)
mask |= mask_1d.reshape(1, -1)
mask[i, :] = False # unmask i'th ramp
image_wrapped = np.ma.array(np.angle(np.exp(1j * image)), mask=mask)
image_unwrapped = unwrap_phase(image_wrapped)
image_unwrapped -= image_unwrapped[0, 0] # remove phase shift
# The end of the unwrapped array should have value equal to the
# endpoint of the unmasked ramp
assert_array_almost_equal_nulp(image_unwrapped[:, -1], image[i, -1])
assert_(np.ma.isMaskedArray(image_unwrapped))
# Same tests, but forcing use of the 3D unwrapper by reshaping
with expected_warnings(['length 1 dimension']):
shape = (1, ) + image_wrapped.shape
image_wrapped_3d = image_wrapped.reshape(shape)
image_unwrapped_3d = unwrap_phase(image_wrapped_3d)
# remove phase shift
image_unwrapped_3d -= image_unwrapped_3d[0, 0, 0]
assert_array_almost_equal_nulp(image_unwrapped_3d[:, :, -1], image[i,
-1])
def check_wrap_around(ndim, axis):
# create a ramp, but with the last pixel along axis equalling the first
elements = 100
ramp = np.linspace(0, 12 * np.pi, elements)
ramp[-1] = ramp[0]
image = ramp.reshape(
tuple([elements if n == axis else 1 for n in range(ndim)]))
image_wrapped = np.angle(np.exp(1j * image))
index_first = tuple([0] * ndim)
index_last = tuple([-1 if n == axis else 0 for n in range(ndim)])
# unwrap the image without wrap around
with warnings.catch_warnings():
# We do not want warnings about length 1 dimensions
warnings.simplefilter("ignore")
image_unwrap_no_wrap_around = unwrap_phase(image_wrapped, seed=0)
print('endpoints without wrap_around:',
image_unwrap_no_wrap_around[index_first],
image_unwrap_no_wrap_around[index_last])
# without wrap around, the endpoints of the image should differ
assert abs(image_unwrap_no_wrap_around[index_first] -
image_unwrap_no_wrap_around[index_last]) > np.pi
# unwrap the image with wrap around
wrap_around = [n == axis for n in range(ndim)]
with warnings.catch_warnings():
# We do not want warnings about length 1 dimensions
warnings.simplefilter("ignore")
image_unwrap_wrap_around = unwrap_phase(image_wrapped,
wrap_around,
seed=0)
print('endpoints with wrap_around:', image_unwrap_wrap_around[index_first],
image_unwrap_wrap_around[index_last])
# with wrap around, the endpoints of the image should be equal
assert_almost_equal(image_unwrap_wrap_around[index_first],
image_unwrap_wrap_around[index_last])
def _unwrapping_phase(img2unwrap, rx=[], ry=[], airpix=[]):
"""
Unwrap the phases of a projection
Parameters
----------
img2unwrap : ndarray
A 2-dimensional array containing the image to be unwrapped
rx, ry : tuple or list of ints
Limits of the are to be unwrapped in x and y
airpix : tuple or list of ints
Position of pixel in the air/vacuum area
Returns
-------
img2unwrap : array_like
Unwrapped image
"""
if rx == [] and ry == []:
img2unwrap = unwrap_phase(im2unwrap)
img2unwrap -= -2 * np.pi * np.round(img2unwrap / (2 * np.pi))
else:
# select the region to be unwrapped
img2wrap_sel = img2unwrap[ry[0]:ry[-1], rx[0]:rx[-1]]
# unwrap the region using the algorithm from skimage
img2unwrap_sel = unwrap_phase(img2wrap_sel)
# update the image in the original array
img2unwrap[ry[0]:ry[-1], rx[0]:rx[-1]] = img2unwrap_sel
img2unwrap[ry[0]:ry[-1], rx[0]:rx[-1]] = (
img2unwrap_sel -
2 * np.pi * np.round(img2unwrap[airpix[1], airpix[0]] /
(2 * np.pi)))
return img2unwrap
def phase(center_1, r_1, center_2, r_2, dataEM):
# Load the elements
ft_holo_1 = np.fft.fft2(dataEM.holo_1)
ft_holo_2 = np.fft.fft2(dataEM.holo_2_aligned)
ft_holo_ref = np.fft.fft2(dataEM.holo_ref)
# Generate the mask in the image space
m_1, g_uns_1 = mask.mask_gaussian(center_1, r_1, ft_holo_1.shape)
m_2, g_uns_2 = mask.mask_gaussian(center_2, r_2, ft_holo_2.shape)
# Mask and calculate the phase component
masked_ft_holo_1 = np.multiply(m_1, np.fft.fftshift(ft_holo_1))
masked_ft_holo_2 = np.multiply(m_2, np.fft.fftshift(ft_holo_2))
masked_ft_holo_ref = np.multiply(m_1, np.fft.fftshift(ft_holo_ref))
# masked_ft_holo_ref_2 = np.multiply(m, np.fft.fftshift(ft_holo_ref_2))
# shift and crop before unwraping
i_fft_1 = np.fft.ifft2(np.fft.ifftshift(masked_ft_holo_1))
i_fft_2 = np.fft.ifft2(np.fft.ifftshift(masked_ft_holo_2))
amplitude_1_distorded = np.abs(i_fft_1)
amplitude_2_distorded = np.abs(i_fft_2)
phase_1_distorded = np.angle(i_fft_1)
phase_2_distorded = np.angle(i_fft_2)
dataEM.phase_ref = unwrap_phase(np.angle(
np.fft.ifft2(np.fft.ifftshift(masked_ft_holo_ref))),
seed=None)
phase_1_distorded_unwrap = unwrap_phase(phase_1_distorded, seed=None)
phase_2_distorded_unwrap = unwrap_phase(phase_2_distorded, seed=None)
phase_1_unwrap = phase_1_distorded_unwrap # - dataEM.phase_ref
phase_2_unwrap = phase_2_distorded_unwrap # - dataEM.phase_ref
amplitude_crop = alignholo.crop_phase([0, 0], amplitude_1_distorded,
amplitude_2_distorded)
dataEM.phase_1 = np.float64(phase_1_distorded_unwrap)
dataEM.phase_2 = np.float64(phase_2_distorded_unwrap)
dataEM.amplitude_1 = amplitude_crop[0]
dataEM.amplitude_2 = amplitude_crop[1]
# dataEM.phase_ref_2 = unwrap_phase(np.angle(np.fft.ifft2(np.fft.ifftshift(masked_ft_holo_ref_2))))
dataEM.diff_1_ref_notsmoothed = dataEM.phase_1
dataEM.diff_2_ref_notsmoothed = dataEM.phase_2
dataEM.diff_2_1_cor_notsmoothed = dataEM.phase_1
dataEM.diff_2_1_not_cor_notsmoothed = dataEM.phase_2
'''dataEM.diff_1_ref = gaussian_filter(dataEM.diff_1_ref_notsmoothed, 6)
dataEM.diff_2_ref = gaussian_filter(dataEM.diff_2_ref_notsmoothed, 6)
dataEM.diff_2_1_not_cor = gaussian_filter(dataEM.diff_2_1_not_cor_notsmoothed, 6)
dataEM.diff_2_1_cor = gaussian_filter(dataEM.diff_2_1_cor_notsmoothed, 6)'''
dataEM.diff_1_ref = dataEM.diff_1_ref_notsmoothed
dataEM.diff_2_ref = dataEM.diff_2_ref_notsmoothed
dataEM.diff_2_1_not_cor = dataEM.diff_2_1_not_cor_notsmoothed
dataEM.diff_2_1_cor = dataEM.diff_2_1_cor_notsmoothed
def test_unwrap_1d():
image = np.linspace(0, 10 * np.pi, 100)
check_unwrap(image)
# Masked arrays are not allowed in 1D
with testing.raises(ValueError):
check_unwrap(image, True)
# wrap_around is not allowed in 1D
with testing.raises(ValueError):
unwrap_phase(image, True, seed=0)
def test_unwrap_1d():
image = np.linspace(0, 10 * np.pi, 100)
check_unwrap(image)
# Masked arrays are not allowed in 1D
with testing.raises(ValueError):
check_unwrap(image, True)
# wrap_around is not allowed in 1D
with testing.raises(ValueError):
unwrap_phase(image, True, seed=0)
def update_ref(Uref, emdata):
def residuals(delta_g_model, delta_g_exp):
delta_g_model_x = delta_g_model[0]
delta_g_model_y = delta_g_model[1]
d_g_x = delta_g_model_x * np.ones(
(delta_g_exp.shape[1], delta_g_exp.shape[2]))
d_g_y = delta_g_model_y * np.ones(
(delta_g_exp.shape[1], delta_g_exp.shape[2]))
d_g = np.array([d_g_x, d_g_y])
err = delta_g_exp - d_g
print('Iteration dans residual')
return err.flatten()
# Load data
emdata_U = emdata.diff_2_1_cor[Uref[1]:Uref[3], Uref[0]:Uref[2]]
model_U = np.array([0, 0])
q_U = np.array([
1 / (2 * np.pi) * np.gradient(unwrap_phase(emdata_U))[0],
1 / (2 * np.pi) * np.gradient(unwrap_phase(emdata_U))[1]
])
emdata_V = emdata.diff_2_1_not_cor[Uref[1]:Uref[3], Uref[0]:Uref[2]]
model_V = np.array([0, 0])
q_V = np.array([
1 / (2 * np.pi) * np.gradient(unwrap_phase(emdata_V))[0],
1 / (2 * np.pi) * np.gradient(unwrap_phase(emdata_V))[1]
])
# Calculate the delta_g_model_u using the least square fit method
model_U = leastsq(residuals, model_U, args=q_U)
print('Resultat du calcul')
print(model_U)
model_V = leastsq(residuals, model_V, args=q_V)
print('Resultat du calcul')
print(model_V)
# Build 3D array of the delta g model on the entire image
d_q_x = model_U[0][0] * np.ones(emdata.diff_2_1_cor.shape)
d_q_y = model_U[0][1] * np.ones(emdata.diff_2_1_cor.shape)
Q_model_3d = np.array([d_q_x, d_q_y])
d_r_x = model_V[0][0] * np.ones(emdata.diff_2_1_not_cor.shape)
d_r_y = model_V[0][1] * np.ones(emdata.diff_2_1_not_cor.shape)
R_model_3d = np.array([d_r_x, d_r_y])
# Recalculate and store phase
mesh_x, mesh_y = np.meshgrid(np.arange(emdata.diff_2_1_cor.shape[1]),
np.arange(emdata.diff_2_1_cor.shape[0]))
emdata.diff_2_1_cor = np.array(
emdata.diff_2_1_cor) - 2 * np.pi * (np.multiply(
Q_model_3d[1], mesh_x) + np.multiply(Q_model_3d[0], mesh_y))
emdata.diff_2_1_not_cor = np.array(
emdata.diff_2_1_not_cor) - 2 * np.pi * (np.multiply(
R_model_3d[1], mesh_x) + np.multiply(R_model_3d[0], mesh_y))
"""def residuals(delta_g_model, delta_g_exp):
def call_unwrap(phase, mask=None, seed=None):
if mask is not None:
assert (mask.shape == phase.shape)
masked = np.ma.masked_array(phase, mask)
phi = np.array(unwrap_phase(masked, seed=seed))
# phi[mask] = phi[np.invert(mask)].mean()
phi[mask] = 0
return phi
else:
return np.array(unwrap_phase(phase, seed=seed))
def phase_retrieval(self, sp=(0, 0), bg=(0, 0), strategy="try"):
# open img
self.sp.open_image()
self.bg.open_image()
check_img_size(self.sp.img)
check_img_size(self.bg.img)
# FFT
self.sp.twodfft()
self.bg.twodfft()
# ----------------------------------------------------------------
x, y = 0, 0
bgx, bgy = 0, 0
if strategy == "try":
x, y = self.try_the_position(self.sp)
bgx, bgy = self.try_the_position(self.bg)
elif strategy == "cheat":
x, y = sp[0], sp[1]
bgx, bgy = bg[0], bg[1]
# crop real or virtual image
self.sp.crop_first_order(x, y, IMAGESIZE//4)
self.bg.crop_first_order(bgx, bgy, IMAGESIZE//4)
print("sp position: ", (x, y), "bg position: ", (bgx, bgy))
# iFFT
self.sp.twodifft(self.sp.crop_raw_f_domain)
self.bg.twodifft(self.bg.crop_raw_f_domain)
self.wrapped_sp = self.sp.iff
self.wrapped_bg = self.bg.iff
# self.plot_fdomain()
# unwapping
self.unwarpped_sp = unwrap_phase(self.wrapped_sp)
self.unwarpped_bg = unwrap_phase(self.wrapped_bg)
# ----------------------------------------------------------------
# shift
sp_mean = np.mean(self.unwarpped_sp)
bg_mean = np.mean(self.unwarpped_bg)
self.unwarpped_sp += np.pi * self.shift(sp_mean)
self.unwarpped_bg += np.pi * self.shift(bg_mean)
# resize
self.final_sp = self.resize_image(self.unwarpped_sp, self.image_size)
self.final_bg = self.resize_image(self.unwarpped_bg, self.image_size)
# subtract
self.final = self.final_sp - self.final_bg
# m_factor
diff = M - np.mean(self.final)
self.final = self.final + diff
def get_unwrapped_phase(self,
*,
aperture: Aperture = None,
z: float = None) -> Tuple[np.ndarray, Aperture]:
if (aperture and z) is not None:
# оптимизация апертуры для правильного разворачивания фазы
aperture.modify(self, z)
return unwrap_phase(self.__phase *
aperture.aperture_view), aperture
else:
return unwrap_phase(self.__phase), aperture
def get_strain(self):
"""
Use the refined phase matrix and g vectors to calculate
the strain matrices.
Returns
-------
e_xx: ndarray
Strain along X direction
e_yy: ndarray
Strain along Y direction
e_th: ndarray
Rotational strain
e_dg: ndarray
Diagonal Strain
Notes
-----
Use the refined G vectors to generate a matrix
of the lattice parameters, which is stored as the
class attribute `a_matrix`. This is multiplied by the
refined phase matrix, and the multiplicand is subsequently
differentiated to get the strain parameters.
See Also
--------
phase_diff
"""
if not self.reference_check:
raise RuntimeError(
"Please refine the phase and g vectors first as refine_phase()"
)
g_matrix = np.zeros((2, 2), dtype=np.float64)
g_matrix[0, :] = np.flip(np.asarray(self.gvec_1_fin))
g_matrix[1, :] = np.flip(np.asarray(self.gvec_2_fin))
self.a_matrix = np.linalg.inv(np.transpose(g_matrix))
P1 = skr.unwrap_phase(self.P_matrix1_fin)
P2 = skr.unwrap_phase(self.P_matrix1_fin)
rolled_p = np.asarray((np.reshape(P1, -1), np.reshape(P2, -1)))
u_matrix = np.matmul(self.a_matrix, rolled_p)
u_x = np.reshape(u_matrix[0, :], P1.shape)
u_y = np.reshape(u_matrix[1, :], P2.shape)
self.e_xx, e_xy = st.gpa.phase_diff(u_x)
e_yx, self.e_yy = st.gpa.phase_diff(u_y)
self.e_th = 0.5 * (e_xy - e_yx)
self.e_dg = 0.5 * (e_xy + e_yx)
self.e_yy -= np.median(self.e_yy[self.ref_reg])
self.e_dg -= np.median(self.e_dg[self.ref_reg])
self.e_th -= np.median(self.e_th[self.ref_reg])
self.e_xx -= np.median(self.e_xx[self.ref_reg])
return self.e_xx, self.e_yy, self.e_th, self.e_dg
def add_atmos(wf, it):
"""
creates a phase offset matrix for each wavelength at each time step,
sampled from the atmosphere generated by hcipy
HCIpy generates an atmosphere with given parameters. The returned field is in units of phase delay for each
wavelength. prop_add_phase wants the phase delay to be in units of meters for each wavelength, so we convert to
meters via the wavelength/np.pi
:param wf: a single (2D) wfo.wf_collection[iw,ib] at one wavelength and object
:param it: timestep# in obs_sequence. Comes from medis_main.gen_timeseries()
:return: nothing returned, wfo is modified with proper.prop_add_phase
"""
if tp.use_atmos is False:
pass # don't do anything. Putting this type of check here allows universal toggling on/off rather than
# commenting/uncommenting in the proper perscription
else:
wavelength = wf.lamda # the .lamda comes from proper, not from Wavefronts class
# Check for Existing File
atmos_map = get_filename(it, wavelength)
# dprint(f"atmos map applied is {atmos_map}")
if not os.path.exists(atmos_map):
gen_atmos(plot=True)
atm_map = fits.open(atmos_map)[1].data
atm_map = unwrap_phase(atm_map)
atm_map *= wavelength / (
2 * np.pi
) # converts atmosphere in units of phase delay (rad) into distance (m)
proper.prop_add_phase(wf, atm_map)
def phase_from_plasma_background(interferogram,
background,
mask,
mask_center,
mask_size,
mask_gauss=False,
remove=True,
unwrap=True):
y1, y2, x1, x2 = mask
img_phase = phase(
inverse_fourier(
apply_mask(fourier(interferogram),
mask_center,
mask_size,
gauss=mask_gauss)))[y1:y2, x1:x2]
back_phase = phase(
inverse_fourier(
apply_mask(fourier(background),
mask_center,
mask_size,
gauss=mask_gauss)))[y1:y2, x1:x2]
if unwrap:
reconstructed_phase = unwrap_phase(back_phase - img_phase)
else:
reconstructed_phase = (np.pi + img_phase -
back_phase) % (2 * np.pi) + np.pi
if remove:
reconstructed_phase = remove_plane(reconstructed_phase)
return reconstructed_phase - reconstructed_phase.min()
def test_unwrap_3d_all_masked():
# all elements masked
image = np.ma.zeros((10, 10, 10))
image[:] = np.ma.masked
unwrap = unwrap_phase(image)
assert_(np.ma.isMaskedArray(unwrap))
assert_(np.all(unwrap.mask))
# 1 unmasked element, still zero edges
image = np.ma.zeros((10, 10, 10))
image[:] = np.ma.masked
image[0, 0, 0] = 0
unwrap = unwrap_phase(image)
assert_(np.ma.isMaskedArray(unwrap))
assert_(np.sum(unwrap.mask) == 999) # all but one masked
assert_(unwrap[0, 0, 0] == 0)
def retrievePF(self, bscale=1.00, psf_diam=50, resample=None):
# an ultrasimplified version
# comment on 08/12: I am still not convinced of the way of setting background.
z_offset, zz = psf_zplane(self.PSF, self.dz, self.l /
3.2) # This should be the reason!!!! >_<
A = self.PF.plane
# z_offset = -z_offset # To deliberately add something wrong
Mx, My = np.meshgrid(
np.arange(self.nx) - self.nx / 2.,
np.arange(self.nx) - self.nx / 2.)
r_pxl = _msqrt(Mx**2 + My**2)
bk_inner = 16
bk_outer = 20
hcyl = np.array(self.nz *
[np.logical_and(r_pxl >= bk_inner, r_pxl < bk_outer)])
background = np.mean(self.PSF[hcyl]) * bscale
print(" background = ", background)
print(" z_offset = ", z_offset)
if (resample == False):
PSF_sample = self.PSF
zs = zz - z_offset
else:
PSF_sample = self.PSF[::resample]
zs = zz[::resample] - z_offset
complex_PF = self.PF.psf2pf(PSF_sample, zs, background, A, self.nIt)
Pupil_final = _PupilFunction(complex_PF, self.PF)
self.pf_complex = Pupil_final.complex
self.pf_phase = unwrap_phase(Pupil_final.phase)
self.pf_ampli = Pupil_final.amplitude
def phase_comp(psi_comp, uwrap=False, dens=None):
"""Compute the phase (angle) of a single complex wavefunction component.
Parameters
----------
psi_comp : NumPy :obj:`array` or PyTorch :obj:`Tensor`
A single wavefunction component.
Returns
-------
angle : NumPy :obj:`array` or PyTorch :obj:`Tensor`
The phase (angle) of the component's wavefunction.
"""
if isinstance(psi_comp, np.ndarray):
ang = np.angle(psi_comp)
if uwrap:
ang = rest.unwrap_phase(ang)
elif isinstance(psi_comp, torch.Tensor):
ang = torch.angle(psi_comp)
if uwrap:
raise NotImplementedError("Unwrapping the complex phase is not "
"implemented for PyTorch tensors.")
if dens is not None:
ang[dens < (dens.max() * 1e-6)] = 0
return ang
def main(out_range=0.4):
image = color.rgb2gray(img_as_float(data.chelsea()))
image = exposure.rescale_intensity(image, out_range=(0, 4 * np.pi))
image_wrapped = np.angle(np.exp(1j * image))
image_unwrapped = unwrap_phase(image_wrapped)
fig, ax = plt.subplots(2, 2, sharex=True, sharey=True)
ax1, ax2, ax3, ax4 = ax.ravel()
fig.colorbar(ax1.imshow(image, cmap='gray', vmin=0, vmax=4 * np.pi),
ax=ax1)
ax1.set_title('Original')
fig.colorbar(ax2.imshow(image_wrapped,
cmap='gray',
vmin=-np.pi,
vmax=np.pi),
ax=ax2)
ax2.set_title('Wrapped phase')
fig.colorbar(ax3.imshow(image_unwrapped, cmap='gray'), ax=ax3)
ax3.set_title('After phase unwrapping')
fig.colorbar(ax4.imshow(image_unwrapped - image, cmap='gray'), ax=ax4)
ax4.set_title('Unwrapped minus original')
plt.tight_layout()
plt.show()
def open_loop_wfs(wfo, plane_name='wfs'):
"""
saves the unwrapped phase [arctan2(imag/real)] of the wfo.wf_collection at each wavelength
It is an idealized image (exact copy) of the wavefront phase per wavelength. Only the map for the first object
(the star) is saved. We have initialized
Here we hardmask on the WFS map to be a circle around the beam in the pupil plane. This hard masking prevents the
DM from acting on non-beam signal, since the DM modelled by proper is a nxn square array, but the beam is nominally
circular for circular apertures.
#TODO the way this is saved for naming the WFS_map is going to break if you want to do closed loop WFS on a
#TODO woofer-tweeter system
:param wfo: wavefront object
:param plane_name: name of the plane to enable or disable saving the WFS map
:return: array containing only the unwrapped phase delay of the wavefront; shape=[n_wavelengths], units=radians
"""
star_wf = wfo.wf_collection[:, 0]
WFS_map = np.zeros((len(star_wf), sp.grid_size, sp.grid_size))
for iw in range(len(star_wf)): # for each wavelength
hardmask_pupil(star_wf[iw])
phasemap = proper.prop_get_phase(star_wf[iw])
WFS_map[iw] = unwrap_phase(phasemap, wrap_around=[False, False])
WFS_map[iw][phasemap == 0] = 0 #TODO is this still necessary?
if 'WFS' in sp.save_list or sp.closed_loop:
wfo.save_plane(location='WFS')
return WFS_map
def unwrap_freq( im ):
max_im = ut.scaling(np.absolute(im))
scaled_im = (im)/max_im*np.pi
#ut.plotim1(im)
im = unwrap_phase(scaled_im.astype(np.float))/np.pi*max_im
ut.plotim1(np.real(im),bar=1)
return im
def unwrap_freq(im):
max_im = 0.8 * ut.scaling(np.absolute(im))
scaled_im = (im) / max_im * np.pi
ut.plotim1(im, bar=1, pause_close=5)
im = unwrap_phase(scaled_im) / np.pi * max_im
ut.plotim1(im, bar=1, pause_close=5)
return im
def view(self,method='log-fft',marker_idx=0,ax=None,show_markers=False,scale=10,colorbar=True,cmap='gray',**kwargs):
marker = self.get_marker(marker_idx)
if method == 'log-fft':
display_image = np.log(1+scale*np.abs(self.fft_image))
label = 'log(1 + scale * |F|)'
elif method == 'masked-log-fft':
display_image = self.apply_mask(np.log(1+scale*np.abs(self.fft_image)),marker)
label = 'log(1 + scale * |F|)'
elif method == 'raw-phase':
display_image = self.raw_phase(marker)
label = 'Raw phase [rad.]'
elif method == 'raw-phase-unwrapped':
display_image = unwrap_phase(self.raw_phase(marker))
label = 'Raw phase [rad.]'
elif method == 'reduced-phase':
display_image = self.reduced_phase(marker)
label = 'Reduced phase [rad.]'
elif method == 'reference-phase':
display_image = self.reference_phase(marker)
label = 'Reference phase [rad.]'
elif method == 'residual-reference-phase':
display_image, optim = self.reciprocal_lattice(marker,return_residual=True)
label = 'Residual reference phase [rad.]'
elif method == 'strain-1d':
display_image = self.strain_1d(marker)*100
label = 'Strain [%]'
elif method == 'exx':
display_image = self.strain()[0,0]*100
label = 'Strain exx [%]'
elif method == 'eyy':
display_image = self.strain()[1,1]*100
label = 'Strain eyy [%]'
elif method == 'planar':
display_image = (self.strain()[0,0]+self.strain()[1,1])/2*100
label = 'Strain (exx + eyy)/2 [%]'
elif method == 'exy' or method == 'eyx':
display_image = self.strain()[1,0]*100
label = 'Strain exy [%]'
elif method == 'rotation':
_, display_image = self.strain(return_rotation=True)/np.pi*180
label = 'Rotation [deg.]'
else:
raise RuntimeError('Method {0} not recognized'.format(method))
if ax is None:
ax=plt.subplot()
imshow=ax.imshow(display_image.T,cmap=cmap,**kwargs)
if colorbar:
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
cbar = plt.colorbar(imshow, cax=cax)
cbar.set_label(label)
if show_markers:
self.marker_collection.add_markers_to_ax(ax)
plt.show()
def planet_phantom_example():
TR, alpha = 24e-3, np.deg2rad(70)
sig, df = load_data()
coil_index = 0
sig = sig[:, :, coil_index, :]
df = df[:, :, coil_index]
sig = sig.transpose((2, 0, 1)) # Move pc to 0 index
sig = sig[..., None]
# Do T1, T2 mapping for each pixel
mask = np.abs(sig[1, :, :, :]) > 5e-8
print('-------')
print(sig.shape)
print(df.shape)
print(mask.shape)
# Do the thing
t0 = perf_counter()
Mmap, T1est, T2est, dfest = planet(sig, alpha, TR, pc_axis=0)
print('Took %g sec to run PLANET' % (perf_counter() - t0))
print(sig.shape)
print(df.shape)
print(dfest.shape)
# Simple phase unwrapping of off-resonance estimate
dfest = unwrap_phase(dfest * 2 * np.pi * TR) / (2 * np.pi * TR)
nx, ny = 3, 3
plt.subplot(nx, ny, 2)
plt.imshow(T1est)
plt.title('T1 est')
plt.axis('off')
plt.subplot(nx, ny, 5)
plt.imshow(T2est)
plt.title('T2 est')
plt.axis('off')
plt.subplot(nx, ny, 7)
plt.imshow(np.abs(df))
plt.title('df Truth')
plt.axis('off')
plt.subplot(nx, ny, 8)
plt.imshow(np.abs(dfest))
plt.title('df est')
plt.axis('off')
plt.subplot(nx, ny, 9)
plt.imshow(np.abs(df - dfest[:, :, 0]))
plt.title('NRMSE: %g' % normalized_root_mse(df, dfest[:, :, 0]))
plt.axis('off')
plt.show()
def main(images):
rows_no = images[0].shape[0]
cols_no = images[0].shape[1]
all_data = np.empty([rows_no, cols_no, len(images)])
for index, image in enumerate(images):
gray_image = convert_image_if_needed(image, convert_to="gray")
all_data[:, :, index] = gray_image
phase_all = all_data[:, :, 0]
# Apply phase calculating from 5 frames
for index_row, row in enumerate(all_data):
for index_col, element in enumerate(row):
phase = phase_calculating(element)
phase_all[index_row, index_col] = phase
# Unwrapping
image_unwrapped = unwrap_phase(phase_all)
# Moving values
image_unwrapped_positive_range = moving_values_to_the_positive_range(
image_unwrapped)
# Substracting fixed component
bez_stalej = substate_fixed_component(image_unwrapped_positive_range)
return bez_stalej
def test_unwrap_3d_all_masked():
# all elements masked
image = np.ma.zeros((10, 10, 10))
image[:] = np.ma.masked
unwrap = unwrap_phase(image)
assert_(np.ma.isMaskedArray(unwrap))
assert_(np.all(unwrap.mask))
# 1 unmasked element, still zero edges
image = np.ma.zeros((10, 10, 10))
image[:] = np.ma.masked
image[0, 0, 0] = 0
unwrap = unwrap_phase(image)
assert_(np.ma.isMaskedArray(unwrap))
assert_(np.sum(unwrap.mask) == 999) # all but one masked
assert_(unwrap[0, 0, 0] == 0)
def retro_wfs(star_fields, wfo, plane_name='wfs'):
"""
Retrospective wfs (measure an old field)
:param star_fields:
:param wfo:
:param plane_name:
:return:
"""
WFS_map = np.zeros((len(star_fields), sp.grid_size, sp.grid_size))
from skimage.restoration import unwrap_phase
for iw in range(len(star_fields)):
quick2D(np.angle(star_fields),
title='before mask',
colormap='sunlight')
phasemap = np.angle(star_fields[iw])
masked_phase = np.ma.masked_equal(phasemap, 0)
quick2D(masked_phase, title='before unwrap', colormap='sunlight')
WFS_map[iw] = unwrap_phase(masked_phase, wrap_around=[False, False])
WFS_map[iw][phasemap == 0] = 0
quick2D(WFS_map[iw], title='after')
if 'retro_closed_wfs' in sp.save_list:
wfo.save_plane(location='WFS_map')
return WFS_map
def from_ftdata(ft, x, y, unwrap=True):
"""Generate a PTF from the Fourier transform of a PSF.
Parameters
----------
ft : `numpy.ndarray`
2D ndarray of Fourier transform data
x : `numpy.ndarray`
1D ndarray of x (axis 1) coordinates
y : `numpy.ndarray`
1D ndarray of y (axis 0) coordinates
unwrap : `bool`, optional
if True, unwrap phase
Returns
-------
`PTF`
a new PTF instance
"""
ft = e.angle(ft)
cy, cx = (int(e.ceil(s / 2)) for s in ft.shape)
offset = ft[cy, cx]
if offset != 0:
ft /= offset
if unwrap:
from skimage import restoration
ft = restoration.unwrap_phase(ft)
return PTF(ft, x, y)
def test_invalid_input():
with testing.raises(ValueError):
unwrap_phase(np.zeros([]))
with testing.raises(ValueError):
unwrap_phase(np.zeros((1, 1, 1, 1)))
with testing.raises(ValueError):
unwrap_phase(np.zeros((1, 1)), 3 * [False])
with testing.raises(ValueError):
unwrap_phase(np.zeros((1, 1)), 'False')
def test_invalid_input():
with testing.raises(ValueError):
unwrap_phase(np.zeros([]))
with testing.raises(ValueError):
unwrap_phase(np.zeros((1, 1, 1, 1)))
with testing.raises(ValueError):
unwrap_phase(np.zeros((1, 1)), 3 * [False])
with testing.raises(ValueError):
unwrap_phase(np.zeros((1, 1)), 'False')
def unwrap_im(im):
"""
Unwrap a np.uint8 phase image. Attention : it doubles the phase jumps.
Parameters
----------
im: numpy.uint8
8-bit grayscale phase image to be unwrapped
Returns
----------
numpy.uint8 unwrapped image
"""
im1 = im
# ax1 = plt.subplot(241)
# ax1.imshow(im1,'gray')
# ax1.set_title('[0, 255]')
# plt.xlim(1,900)
# plt.ylim(1,900)
# plt.xticks([1, 900])
# plt.yticks([1, 900])
im2 = exposure.rescale_intensity(1.0 * im1,
in_range=(0, 255),
out_range=(0, 4 * np.pi))
# ax2 = plt.subplot(242)
# ax2.imshow(im2,'gray')
# ax2.set_title(r'$[0, 4\pi]$')
# plt.xlim(1,900)
# plt.ylim(1,900)
# plt.xticks([1, 900])
# plt.yticks([1, 900])
im3 = np.angle(np.exp(1j * im2))
# ax3 = plt.subplot(243)
# ax3.imshow(im3,'gray')
# ax3.set_title(r'$[-\pi, +\pi]$')
# plt.xlim(1,900)
# plt.ylim(1,900)
# plt.xticks([1, 900])
# plt.yticks([1, 900])
im4 = restoration.unwrap_phase(im3)
# ax4 = plt.subplot(244)
# ax4.imshow(im4,'gray')
# ax4.set_title(r'Modified image: ??')
# plt.xlim(1,900)
# plt.ylim(1,900)
# plt.xticks([1, 900])
# plt.yticks([1, 900])
return im4
def check_unwrap(image, mask=None):
image_wrapped = np.angle(np.exp(1j * image))
if mask is not None:
print('Testing a masked image')
image = np.ma.array(image, mask=mask, fill_value=0.5)
image_wrapped = np.ma.array(image_wrapped, mask=mask, fill_value=0.5)
image_unwrapped = unwrap_phase(image_wrapped, seed=0)
assert_phase_almost_equal(image_unwrapped, image)
def check_unwrap(image, mask=None):
image_wrapped = np.angle(np.exp(1j * image))
if mask is not None:
print('Testing a masked image')
image = np.ma.array(image, mask=mask)
image_wrapped = np.ma.array(image_wrapped, mask=mask)
image_unwrapped = unwrap_phase(image_wrapped, seed=0)
assert_phase_almost_equal(image_unwrapped, image)
def check_unwrap(image, mask=None):
image_wrapped = np.angle(np.exp(1j * image))
if not mask is None:
print('Testing a masked image')
image = np.ma.array(image, mask=mask)
image_wrapped = np.ma.array(image_wrapped, mask=mask)
image_unwrapped = unwrap_phase(image_wrapped)
assert_phase_almost_equal(image_unwrapped, image)
def plot_2d_complex(input_array,
mode='linear',
name='input_array',
*args,
**kwargs):
fig, (ax1, ax2) = plt.subplots(1, 2)
if 'coords' in kwargs:
if mode == 'linear':
im1 = ax1.imshow((np.abs(input_array)), extent=kwargs['coords'])
if mode == 'log':
im1 = ax1.imshow(np.log((np.abs(input_array))),
extent=kwargs['coords'])
ax1.title.set_text('magnitude of ' + str(name) + ' ( in ' + str(mode) +
' scale)')
ax1.title.set_y(1.08)
fig.colorbar(im1, ax=ax1)
scaling = np.round(np.log10(np.abs(kwargs['coords'][0])))
scaling = np.int(scaling)
ax1.set_xlabel('axes in 10^(' + str(scaling) + ')')
im2 = ax2.imshow(unwrap_phase(np.angle(input_array)),
extent=kwargs['coords'])
ax2.title.set_text('phase of ' + str(name))
ax2.title.set_y(1.08)
fig.subplots_adjust(right=1.75)
ax2.set_xlabel('axes in 10^(' + str(scaling) + ')')
fig.colorbar(im2, ax=ax2)
else:
if mode == 'linear':
im1 = ax1.imshow((np.abs(input_array)))
if mode == 'log':
im1 = ax1.imshow(np.log((np.abs(input_array))))
ax1.title.set_text('magnitude of ' + str(name) + ' ( in ' +
str(mode) + ' scale)')
ax1.title.set_y(1.08)
fig.colorbar(im1, ax=ax1)
im2 = ax2.imshow(unwrap_phase(np.angle(input_array)))
ax2.title.set_text('phase of ' + str(name))
ax2.title.set_y(1.08)
fig.subplots_adjust(right=1.75)
fig.colorbar(im2, ax=ax2)
plt.show()
if 'print_max' in args:
print('maximum value of ' + str(name) + ': ', np.max(abs(input_array)))
print('minimum value of ' + str(name) + ': ', np.min(abs(input_array)))
print('location of maxima in ' + str(name) + ': ',
np.where(abs(input_array) == np.max(abs(input_array))))
def test_unwrap_2d_all_masked():
# Segmentation fault when image is masked array with a all elements masked
# GitHub issue #1347
# all elements masked
image = np.ma.zeros((10, 10))
image[:] = np.ma.masked
unwrap = unwrap_phase(image)
assert_(np.ma.isMaskedArray(unwrap))
assert_(np.all(unwrap.mask))
# 1 unmasked element, still zero edges
image = np.ma.zeros((10, 10))
image[:] = np.ma.masked
image[0, 0] = 0
unwrap = unwrap_phase(image)
assert_(np.ma.isMaskedArray(unwrap))
assert_(np.sum(unwrap.mask) == 99) # all but one masked
assert_(unwrap[0, 0] == 0)
def test_unwrap_2d_all_masked():
# Segmentation fault when image is masked array with a all elements masked
# GitHub issue #1347
# all elements masked
image = np.ma.zeros((10, 10))
image[:] = np.ma.masked
unwrap = unwrap_phase(image)
assert_(np.ma.isMaskedArray(unwrap))
assert_(np.all(unwrap.mask))
# 1 unmasked element, still zero edges
image = np.ma.zeros((10, 10))
image[:] = np.ma.masked
image[0, 0] = 0
unwrap = unwrap_phase(image)
assert_(np.ma.isMaskedArray(unwrap))
assert_(np.sum(unwrap.mask) == 99) # all but one masked
assert_(unwrap[0, 0] == 0)
def load_folder_pupil(folder, flag = 'mod', radius = 49 ):
# load and plot all the pupil functions in the chosen folder.
pupil_list = glob.glob(folder + '*'+ flag+'*.npy')
pupil_list.sort(key = os.path.getmtime)
for pname in pupil_list:
session_name = os.path.basename(pname).split('.')[0]
pupil_name = session_name + '_pupil'
print(session_name)
raw_pupil = unwrap_phase(np.load(pname))/(2*np.pi) # convert to wavelength
pupil = pupil_crop(raw_pupil,mask = True, rad = radius)
figp = pupil_showcross(pupil)
figp.savefig(folder+pupil_name)
plt.close()
def single_2Dgrating_analyses(img, img_ref=None, harmonicPeriod=None,
unwrapFlag=True, plotFlag=True, verbose=False):
"""
Function to process the data of single 2D grating Talbot imaging. It
wraps other functions in order to make all the process transparent
"""
# Obtain Harmonic images
h_img = single_grating_harmonic_images(img, harmonicPeriod,
plotFlag=plotFlag,
verbose=verbose)
if img_ref is not None: # relative wavefront
h_img_ref = single_grating_harmonic_images(img_ref, harmonicPeriod,
plotFlag=plotFlag,
verbose=verbose)
int00 = np.abs(h_img[0])/np.abs(h_img_ref[0])
int01 = np.abs(h_img[1])/np.abs(h_img_ref[1])
int10 = np.abs(h_img[2])/np.abs(h_img_ref[2])
if unwrapFlag is True:
arg01 = (unwrap_phase(np.angle(h_img[1]), seed=72673) -
unwrap_phase(np.angle(h_img_ref[1]), seed=72673))
arg10 = (unwrap_phase(np.angle(h_img[2]), seed=72673) -
unwrap_phase(np.angle(h_img_ref[2]), seed=72673))
else:
arg01 = np.angle(h_img[1]) - np.angle(h_img_ref[1])
arg10 = np.angle(h_img[2]) - np.angle(h_img_ref[2])
else: # absolute wavefront
int00 = np.abs(h_img[0])
int01 = np.abs(h_img[1])
int10 = np.abs(h_img[2])
if unwrapFlag is True:
arg01 = unwrap_phase(np.angle(h_img[1]), seed=72673)
arg10 = unwrap_phase(np.angle(h_img[2]), seed=72673)
else:
arg01 = np.angle(h_img[1])
arg10 = np.angle(h_img[2])
if unwrapFlag is True: # remove pi jump
arg01 -= int(np.round(np.mean(arg01/np.pi)))*np.pi
arg10 -= int(np.round(np.mean(arg10/np.pi)))*np.pi
darkField01 = int01/int00
darkField10 = int10/int00
return [int00, int01, int10,
darkField01, darkField10,
arg01, arg10]
def wave_retrieval(data,r_data=None,filt=None,STEPS=False,s=0.1,ARGS=False):
# go to fourier space
f_data = np.fft.fft2(data)
# get the k-vector (lots of finagling here for fft shift crap)
if r_data is None:
K = get_wave(f_data)
kx,ky = np.fft.fftfreq(f_data.shape[0]),np.fft.fftfreq(f_data.shape[1])
k = kx[K[0]],ky[K[1]]
nx,ny = data.shape
Y,X = np.meshgrid(np.arange(nx),np.arange(ny),sparse=False,indexing='xy')
# phplot.imageshow(data)
# phplot.imageshow(np.real(r_data))
# phplot.imageshow(np.real(r_data*np.exp(+1j*2.*np.pi*(k[0]*X+k[1]*Y))))
# reference beam
r_data = np.exp(+1j*2.*np.pi*(k[0]*X+k[1]*Y))
# filter k-space with a gaussian around data of interest
if filt is None:
try:
gf_data = f_gaussian(f_data,K)*f_data
except UnboundLocalError:
K = get_wave(f_data)
finally:
gf_data = f_gaussian(f_data,K)*f_data
filt = np.ones(f_data.shape)
filt = f_gaussian(filt,K)*filt
# band = get_band(data,K)
# filt = f_bandpass(filt,band)
# filt = hilbert_transform(filt,'x')
else:
gf_data = filt*f_data
# check it out!!
# phplot.imageshow(phplot.dB_data(gauss_filter))
# go back to xy space
g_data = np.fft.ifft2(gf_data)
o_data = g_data*r_data # retrieve the wrapped phase from the digital reference beam
wrapped_phase = np.arctan2(o_data.imag,o_data.real)
# unwrap the phase (may be unneccesary)
unwrapped_phase = unwrap_phase(wrapped_phase)
phase = unwrapped_phase
#phase = wrapped_phase
if STEPS:
return data,f_data,gauss_filter,wrapped_phase,unwrapped_phase,plane,phase
if ARGS:
return -phase,r_data,filt
return -phase
def parse_enz_solution(cfg, betak):
if betak.ndim == 2:
gpf = cfg.cpsf.czern.eval_grid(betak[:, 0])
else:
gpf = cfg.cpsf.czern.eval_grid(betak)
wrph = np.arctan2(gpf.imag, gpf.real)
wrph = np.mod(wrph, 2*np.pi) - np.pi
ut1 = time()
unph = unwrap_phase(wrph.reshape(
(cfg.fit_L, cfg.fit_K), order='F')).ravel(order='F')
ut2 = time()
ft1 = time()
alpha_hat = cfg.phase_fit.fit(unph)
ft2 = time()
alpha_hat[0] = 0.0
return alpha_hat, ft2 - ft1, ut2 - ut1, wrph, unph
def compute_local_phase_field(camp):
""" Compute local phase of each cell
"""
width, height, depth = camp.shape
# compute thetas
tau = compute_tau(camp)
theta = np.empty((width, height)).tolist()
for j in range(width):
for i in range(height):
cur = compute_phase_variable(camp[i, j], tau)
theta[i][j] = np.array(cur)
theta = np.rollaxis(np.array(theta), 2, 0)
# fix phase jumps greater than PI
for i in range(len(theta)):
theta[i] = unwrap_phase(theta[i])
return theta
def hilbert_retrieval(data,plane=None,filt=None,STEPS=False,direction='x',ARGS=False):
# fourier transform data and filter
window_f = np.hanning
w2 = np.sqrt(np.outer(window_f(data.shape[0]),window_f(data.shape[1])))
f_data = np.fft.fft2(data)
if filt is None:
band = get_band(f_data)
filt_f_data = f_bandpass(f_data,band)
hilbert_f_data = hilbert_transform(filt_f_data,direction)
filt = np.ones(f_data.shape)
filt = f_bandpass(filt,band)
filt = hilbert_transform(filt,direction)
else:
hilbert_f_data = f_data *filt
# hilbert-transform
# phplot.imageshow(phplot.dB_data(filt_f_data))
hilbert_data = np.fft.ifft2(hilbert_f_data)
# retrieve the wrapped phase
wrapped_phase = np.arctan2(hilbert_data.imag,hilbert_data.real)
# unwrap the phase
unwrapped_phase = unwrap_phase(wrapped_phase)
# flatten the data (if required - some methods can use the same level for all data)
if plane is None:
plane = diff_level(unwrapped_phase)
phase = unwrapped_phase - plane
if STEPS:
return data,f_data,filt_f_data,hilbert_f_data,hilbert_data,wrapped_phase,unwrapped_phase,plane,phase
if ARGS:
return -phase,plane,filt
return -phase
def diagnosticPlot(solver):
"""
Returns a matplotlib figure
"""
ur = pint.UnitRegistry()
MASK_CUTOFF = 1.0
# N_PHASE_TICKS = 6
NUM_COLOURS = 100
# DISP_FRACTION = 1/10
KS_FRACTION = 1/4
ur = UnitRegistry()
x, y = solver.grid.getSpatialGrid(scaled=False)
x *= 1e6
y *= 1e6
x_ax = x[0, :]
y_ax = y[:, 0]
psi = solver.psi.get()
# n = solver.n.get()
P = solver.Pdt.get()
P /= solver.dt
N = psi.shape[0]
time = solver.times
energy = solver.energy
number = solver.number
pumpSlice = P[N/2, :]
PthScaled = solver.Pth / np.max(P)
pumpSlice /= np.max(P)
rMiddle = abs(x[N/2, np.argmax(pumpSlice)])
density = solver.getDensity(scaled=True)
pumpCircle = plt.Circle((0.0, 0.0), radius=rMiddle, color='w',
linestyle='dashed', fill=False)
fig, axes = plt.subplots(2, 3)
time = solver.times
energy = solver.energy
number = solver.number
density = solver.getDensity(scaled=True)
pumpCircle = plt.Circle((0.0, 0.0), radius=rMiddle, color='w',
linestyle='dashed', fill=False)
fig, axes = plt.subplots(2, 3)
fig, axes = plt.subplots(2, 3)
p0 = axes[0, 0].contourf(x, y, density, NUM_COLOURS)
# RS density
axes[0, 0].set_title("Density $\mu m ^{-2}$")
# axes[0, 0].set_aspect('equal', 'box')
axes[0, 0].set_aspect(1./axes[0, 0].get_data_ratio())
axes[0, 0].add_artist(pumpCircle)
plt.colorbar(p0, ax=axes[0, 0], fraction=0.046, pad=0.04)
# KS density
ksDensity = np.absolute(fft.fftshift(fft.fft2(psi)))
ksLowerLim = int(N/2 - KS_FRACTION * N / 2)
ksUpperLim = int(N/2 + KS_FRACTION * N / 2)
p1 = axes[1, 0].contourf(x_ax[ksLowerLim:ksUpperLim],
y_ax[ksLowerLim:ksUpperLim],
ksDensity[ksLowerLim:ksUpperLim,
ksLowerLim:ksUpperLim] /
np.max(ksDensity), NUM_COLOURS)
axes[1, 0].set_title("KS Density")
axes[1, 0].set_aspect('equal')
plt.colorbar(p1, ax=axes[1, 0], fraction=0.046, pad=0.04)
# Phase
# p2 = axes[0, 1].contourf(x, y, np.angle(psi) + np.pi)
phase = unwrap_phase(np.angle(psi))
# Mask the values that are out the damping region are ignored
mask = solver.damping.get() < MASK_CUTOFF
phase = np.ma.array(phase, mask=mask) / np.pi
# Set the minumum phase to zero
phase -= np.min(phase)
# maxPhase = np.ceil(np.max(phase) / np.pi)
# minPhase = np.floor(np.min(phase) / np.pi)
# step = np.ceil((maxPhase - minPhase) / N_PHASE_TICKS)
# ticks = np.pi * np.arange(minPhase, maxPhase + 1, step=step)
# labels = ["$%d \pi$" % i for i in np.arange(minPhase, maxPhase + 1)]
p2 = axes[0, 1].contourf(x, y, phase, NUM_COLOURS)
axes[0, 1].set_title("Phase")
# axes[0, 1].set_aspect('equal', 'box')
axes[0, 1].set_aspect(1./axes[0, 1].get_data_ratio())
pumpCircle = plt.Circle((0.0, 0.0), radius=rMiddle, color='w',
linestyle='dashed', fill=False)
axes[0, 1].add_artist(pumpCircle)
cbar2 = plt.colorbar(p2, ax=axes[0, 1], fraction=0.046, pad=0.04)
labels = [t.get_text() + '$\pi$' for t in cbar2.ax.get_yticklabels()]
# cbar2 = plt.colorbar(p2, ax=axes[0, 1],
# ticks=ticks,
# fraction=0.046, pad=0.04)
cbar2.ax.set_yticklabels(labels)
# cbar2 = plt.colorbar(p2, ax=axes[0, 1],
# ticks=np.pi * np.array([0, 1.0, 2.0]),
# fraction=0.046, pad=0.04)
# cbar2.ax.set_yticklabels(['0', '$\pi$', '$2\pi$'])
# Resovoir density
# p4 = axes[1, 1].contourf(x, y, n, NUM_COLOURS)
# axes[1, 1].set_title("Resovoir density")
# # axes[1, 1].set_aspect('equal', 'box')
# axes[1, 1].set_aspect(1./axes[1, 1].get_data_ratio())
# pumpCircle = plt.Circle((0.0, 0.0), radius=rMiddle, color='w',
# linestyle='dashed', fill=False)
# axes[1, 1].add_artist(pumpCircle)
# plt.colorbar(p4, ax=axes[1, 1], fraction=0.046, pad=0.04)
# Dispersion relation
# dispLowerLim = int(N/2 - DISP_FRACTION * N / 2)
# dispUpperLim = int(N/2 + DISP_FRACTION * N / 2)
# Account for the fact that we have cut off some of the k axis in the
# spectrum
spectMax = int(solver.spectrum.shape[1])//2
k_ax = solver.grid.k_axis_scaled[N//2 - spectMax:N//2 + spectMax]
# Omega axis in units of 1 / seconds
omega_axis = solver.omega_axis / ur.Quantity(solver.charT,
ur.second.to_base_units().
units)
# Energy axis in milliev
energy_axis = (omega_axis * ur.hbar).to("millieV").magnitude
m = ur.Quantity(solver.paramContainer.getOutputParams()["m"].magnitude,
"electron_mass")
L = ur.Quantity(solver.paramContainer.getOutputParams()["charL"].magnitude,
"micrometer")
dispCurve = ((ur.hbar**2 * k_ax**2) / (2 * m * L**2)).to("millieV")\
.magnitude
# p4 = axes[1, 1].contourf(solver.grid.k_axis_scaled[dispLowerLim:
# dispUpperLim],
# energy_axis,
# np.absolute(solver.spectrum)[:, dispLowerLim:
# dispUpperLim],
# NUM_COLOURS)
axes[1, 1].contourf(k_ax, energy_axis, np.absolute(solver.spectrum),
NUM_COLOURS)
axes[1, 1].plot(k_ax, dispCurve, color='w', ls=":", lw=0.2)
yu = 5
yl = -2
axes[1, 1].set_ylim([yl, yu])
# yl = - 1
# print "yu = %f" % yu
# print axes[1, 1].get_ylim()
# axes[1,1].set_ylim([-1, 10])
# p4 = axes[1, 1].contourf(np.absolute(solver.spectrum)[:, N/4:3*N/4],
# NUM_COLOURS)
axes[1, 1].set_title("Dispersion Relation")
# axes[1, 0].set_aspect('equal')
axes[1, 1].set_aspect(1./axes[1, 1].get_data_ratio())
axes[1, 1].set_xlabel('k')
axes[1, 1].set_ylabel('E (meV)')
# plt.colorbar(p1, ax=axes[1, 0], fraction=0.046, pad=0.04)
# Radial profile
psiMax = np.max(np.absolute(psi[N/2, :]))
# axes[0, 2].plot(x[N/2, :], np.absolute(psi[N/2, :]) / psiMax,
# x[N/2, :], pumpFunction(x, y)[N/2, :] / pfMax)
# axes[0, 2].axhline(PthScaled)
axes[0, 2].plot(x_ax[N/4:3*N/4], np.absolute(psi[N/2, N/4:3*N/4])/psiMax,
x_ax[N/4:3*N/4], pumpSlice[N/4:3*N/4])
axes[0, 2].set_title("Radial Profile")
axes[0, 2].set_ylabel("Density")
axes[0, 2].set_xlabel("x")
axes[0, 2].set_aspect(1./axes[0, 2].get_data_ratio())
# Energy and number
axes[1, 2].plot(time, energy, color='k')
axes[1, 2].ticklabel_format(style='sci', scilimits=(-3, 3), axis='y')
# axes[1, 2].set_title("Energy")
axes[1, 2].set_xlabel("Time")
axes[1, 2].set_ylabel("Energy")
ax2 = axes[1, 2].twinx()
ax2.plot(time, number, 'b')
ax2.ticklabel_format(style='sci', scilimits=(-3, 3), axis='y')
ax2.set_ylabel("Number", color='b')
for t1 in ax2.get_yticklabels():
t1.set_color('b')
ax2.set_aspect(1./ax2.get_data_ratio())
# Plot lines to indicate the start and end of spectrum acquisition
axes[1, 2].axvline(solver.dt * solver.spectStartStep, linestyle='-')
axes[1, 2].axvline(solver.dt * solver.spectEndStep, linestyle='-')
axes[1, 2].set_aspect(1./axes[1, 2].get_data_ratio())
fig.tight_layout()
return fig
wpu.plot_slide_colorbar(intensity,
title='Intensity',
xlabel=r'x [$\mu m$]',
ylabel=r'y [$\mu m$]',
extent=wpu.extent_func(dpc_1d, pixelSize)*1e6)
# %% Dark Field
wpu.plot_slide_colorbar(dk_field, title='Dark Field',
xlabel=r'x [$\mu m$]',
ylabel=r'y [$\mu m$]',
extent=wpu.extent_func(dpc_1d, pixelSize)*1e6)
# %% DPC
dpc_1d = unwrap_phase(dpc_1d)
wpu.plot_slide_colorbar(dpc_1d/np.pi/2.0,
title=r'DPC [$\pi rad$]',
xlabel=r'x [$\mu m$]',
ylabel=r'y [$\mu m$]',
extent=wpu.extent_func(dpc_1d, pixelSize)*1e6)
# %%
xx, yy = wpu.realcoordmatrix(dpc_1d.shape[1], pixelSize,
dpc_1d.shape[0], pixelSize)
wpu.plot_profile(xx*1e3, yy*1e3, dpc_1d/np.pi/2.0,
xlabel='[mm]', ylabel='[mm]')
# %% chi2
plt.figure()
def complex(self, new):
self._complex = new
self._amplitude = abs(new)
self._phase = unwrap_phase(np.angle(new))
n = 1.33
NA = 1.00
f = 9000
nIt = 4
# PSF = PSF2
path = path1
ii=1
plt.close('all')
for pfile in PSF_list30:
PSF = np.load(pfile)
PF = retrievePF(PSF, dx, dz, l, n, NA, f, nIt)
PF = unwrap_phase(PF)
plt.figure(figsize=(4.5,4))
# plt.imshow(PF, cmap = 'RdBu', )
im = plt.imshow(PF, cmap = plt.cm.RdBu, extent=(-2,2,2,-2))
plt.tick_params(
axis = 'both',
which = 'both',
bottom = 'off',
top = 'off',
right = 'off',
left = 'off',
labelleft='off',
labelbottom = 'off')
plt.tight_layout()
#if i == h/2:
# plt.figure()
# plt.plot(fft)
# do shifting
fft_shift = fft
# clear duplicates and DC
fft_shift[0:w/2]=0
fft_shift[w-1:len(row)]=0
# shift
fft_shift = np.roll(fft_shift,ind)
c = np.fft.ifft(fft_shift)
phi[i,:] = np.log(c).imag
unwrapped = unwrap_phase(phi)
plt.figure(figsize = (12,6) )
plt.gray()
plt.subplot(131)
plt.imshow(img)
plt.title("Image")
plt.subplot(132)
plt.imshow(phi)
plt.title("Wrapped Phase")
plt.subplot(133)
plt.imshow(unwrapped)
plt.title("Unwrapped Phase")
def unwrap(self):
unwrapped = unwrap_phase(self._PF.phase)
return unwrapped
"""
import numpy as np
from matplotlib import pyplot as plt
from skimage import data, img_as_float, color, exposure
from skimage.restoration import unwrap_phase
# Load an image as a floating-point grayscale
image = color.rgb2gray(img_as_float(data.chelsea()))
# Scale the image to [0, 4*pi]
image = exposure.rescale_intensity(image, out_range=(0, 4 * np.pi))
# Create a phase-wrapped image in the interval [-pi, pi)
image_wrapped = np.angle(np.exp(1j * image))
# Perform phase unwrapping
image_unwrapped = unwrap_phase(image_wrapped)
fig, ax = plt.subplots(2, 2)
ax1, ax2, ax3, ax4 = ax.ravel()
fig.colorbar(ax1.imshow(image, cmap='gray', vmin=0, vmax=4 * np.pi), ax=ax1)
ax1.set_title('Original')
fig.colorbar(ax2.imshow(image_wrapped, cmap='gray', vmin=-np.pi, vmax=np.pi), ax=ax2)
ax2.set_title('Wrapped phase')
fig.colorbar(ax3.imshow(image_unwrapped, cmap='gray'), ax=ax3)
ax3.set_title('After phase unwrapping')
fig.colorbar(ax4.imshow(image_unwrapped - image, cmap='gray'), ax=ax4)
ax4.set_title('Unwrapped minus original')
def unwrap(self):
self.phi = unwrap_phase(self.phi)
#self.phi = np.unwrap(self.phi)
pass
templateX, templateY, templateWidth = locate_glowplug(img, approxTemplate, debug=False)
template = get_autolite_template(templateWidth+templateSlop, img_h/2)
## perform analysis
if not os.path.exists('results'):
os.makedirs('results')
frameNums = map(str,frameNums)
for i in frameNums:
imageFilename = ('cropped/' + imageFileBase + i + '_crop.jpg')
orig = WTP.imagefile2dat(imageFilename)
wrapped = WTP.performWTP(wavelet_type = wavelet_type, ridge_alg = ridge_alg,
starting_scale = starting_scale, ending_scale=ending_scale, use_FFT=use_FFT, Morlet_sigma=Morlet_sigma)
unwrapped = unwrap_phase(wrapped)
phase = unbias_image(unwrapped)
masked = remove_glowplug(phase, templateX-templateSlop/2, templateY, template)
x, y, centered = center_image_x(masked, templateX + templateWidth/2, templateY, dx)
r, f_abel, deriv, smoothed = perform_abel_discontinuous(x, centered)
delta_n = f_abel*lam / (2*np.pi)
rho= (n_air - delta_n - 1)/K_air
fileroot = ('results/' + imageFileBase + i + '_crop')
np.savetxt(fileroot+"_orig.csv", orig, delimiter=",")
np.savetxt(fileroot+"_wrapped.csv", wrapped, delimiter=",")
def test_unwrap_3d_middle_wrap_around():
# Segmentation fault in 3D unwrap phase with middle dimension connected
# GitHub issue #1171
image = np.zeros((20, 30, 40), dtype=np.float32)
unwrap = unwrap_phase(image, wrap_around=[False, True, False])
assert_(np.all(unwrap == 0))
def test_unwrap_2d_compressed_mask():
# ValueError when image is masked array with a compressed mask (no masked
# elments). GitHub issue #1346
image = np.ma.zeros((10, 10))
unwrap = unwrap_phase(image)
assert_(np.all(unwrap == 0))
