def generate_A0ft_svd_list(self):
A0ft_list = EM.unshifted_basis_ft_svd_list(self.var_theta,
self.var_rad,
self.dtheta,
self.drad,
self.num_theta,
self.num_rad)
return A0ft_list
def generate_A0_stack(ringModel):
A0_stack = EM.unshifted_basis_matrix_stack(ringModel.var_theta,
ringModel.var_rad,
ringModel.dtheta,
ringModel.drad,
ringModel.num_theta,
ringModel.num_rad)
return A0_stack
B_rad_dx = np.empty(0)
B_rad_dy = np.empty(0)
B_rad_var = np.empty(0)
for i_az, az in enumerate(az_means):
print(i_az)
x_radii, y_radii = RingIP.line_normal_to_ellipse(az_x0[i_az],
az_y0[i_az],
rsf.a,rsf.b,
rad_distances)
dx = az_x0[i_az] - x_radii.ravel()
dy = az_y0[i_az] - y_radii.ravel()
for j in range(len(dx)):
for rad_var in rad_variance_domain:
B0 = EM.ellipse_basis_single_spot([x_mask,y_mask],rsf.a,rsf.b,
rsf.xc,rsf.zc,dx[j],dy[j],
az,num_theta,rad_var,
az_variances[i_az])
B = np.hstack([B,B0[:,None]])
B_az_mean = np.append(B_az_mean,az)
B_az_var = np.append(B_az_var,az_variances[i_az])
B_rad_dx = np.append(B_rad_dx,dx[j])
B_rad_dy = np.append(B_rad_dy,dy[j])
B_rad_var = np.append(B_rad_var,rad_var)
#wsqanp.save(os.path.join(name,'full_ellipse_basis.npy'),B)
# might need to adjust the units of az (azimuthal mean)
# Construct 2d elliptic basis matrix based on 1d fit and define the
# basis path. Only `
# Try and make it stored as a sparse matrix? How can I tell if this
num_rad = 2 * dr
num_var_t = 15
num_var_r = 10
dtheta = 2 * np.pi / num_theta
drad = 1
var_theta = np.linspace((dtheta), (np.pi / 32), num_var_t)**2
var_rad = np.linspace(drad, 3, num_var_r)**2
# Compute basis matrix and interpolate ring to polar coordinates
ringModel = RM.RingModel(load_step, img_nums[0], radius - dr, radius + dr,
num_theta, num_rad, dtheta, drad, var_theta, var_rad)
A0ft_stack = EM.unshifted_basis_matrix_ft_stack(
ringModel.var_theta, ringModel.var_rad, ringModel.dtheta, ringModel.drad,
ringModel.num_theta, ringModel.num_rad)
ringModel.l1_ratio = 1
ringModel.max_iters = 500
ringModel.lipschitz = 6e5
out_path = os.path.join('..', 'CHESS_results', 'ringModel_out')
ringModel_list = []
for img_num in img_nums:
img_file = 'polar_image_al7075_load_' + str(load_step) + '_img_' + str(
img_num) + '.npy'
img_path = os.path.join('..', 'CHESS_data', img_file)
ringModel = RM.RingModel(load_step, img_num, radius - dr, radius + dr,
num_theta, num_rad, dtheta, drad, var_theta,
r_coord = np.transpose(r_coord)
theta_coord = theta.copy()
for i in range(num_r - 1):
theta_coord = np.vstack((theta_coord, theta))
#%% Stack up a bunch of test images shiftes in theta using 2D gaussian basis
m_r = num_r / 2
m_theta = np.linspace(0, num_theta, num_r)
v_r = num_r / 2
v_theta = num_theta / 2
images = np.zeros((num_theta, 0))
for j in range(num_r):
dr = 1
dtheta = 1
B = EM.gaussian_basis_wrap_2D(num_theta, dtheta, m_theta[j], v_theta,
num_r, dr, m_r, v_r)
img = B.reshape((num_theta, num_r))
images = np.append(images, img, 1)
plt.imshow(images)
#%% Test 2D convolution to generate 2D shifted Gaussian basis functions
num_r = 500
num_theta = 500
v_r = num_r / 2
v_theta = num_theta / 2
m_r = 0
m_theta = 0
dr = 1
dtheta = 1
B0 = EM.gaussian_basis_wrap_2D(num_theta, dtheta, m_theta, v_theta, num_r, dr,
m_r, v_r).reshape((num_theta, num_r))
num_var_t = 6
num_var_r = 5
dtheta = 2 * np.pi / num_theta
drad = 1
var_theta = np.linspace((dtheta), (np.pi / 32), num_var_t)**2
var_rad = np.linspace(drad, 3, num_var_r)**2
# Initialize Ring Model
ringModel = RM.RingModel(load_step, img_num, radius - dr, radius + dr,
num_theta, num_rad, dtheta, drad, var_theta, var_rad)
# Compute basis matrix and interpolate ring to polar coordinates
A0_stack = EM.unshifted_basis_matrix_stack(ringModel.var_theta,
ringModel.var_rad, ringModel.dtheta,
ringModel.drad, ringModel.num_theta,
ringModel.num_rad)
#A0ft_svd_list = ringModel.generate_basis_matrices()
ringModel.l1_ratio = 1
ringModel.max_iters = 500
ringModel.compute_lipschitz(A0_stack)
synth_image_list = []
for j in range(3):
synth_image = np.zeros((num_rad, num_theta))
for i in range(5):
rand_t = random.randint(0, num_var_t - 1)
rand_r = random.randint(0, num_var_r - 1)
rand_theta = random.randint(0, num_theta - 1)
dtheta = 2*np.pi/num_theta
dr = 30
num_rad = 2*dr
drad = 1
# Create fitting matrix
reload(EM)
reload(LassoSolvers)
num_var_t = 15
num_var_r = 10
var_theta = np.linspace((dtheta),(np.pi/16),num_var_t)**2
var_rad = np.linspace(drad,10,num_var_r)**2
#Store stack of image slices
B0ft_stack = EM.unshifted_basis_matrix_stack(var_theta,var_rad,dtheta,drad,num_theta,num_rad)
B0ft_list = EM.unshifted_basis_matrix_list(var_theta,var_rad,dtheta,drad,num_theta,num_rad)
B0ft_list_svd = EM.unshifted_basis_svd_list(var_theta,var_rad,dtheta,drad,num_theta,num_rad)
x = np.random.rand(num_rad,num_theta,num_var_t,num_var_r)
R = np.random.rand(num_rad,num_theta)
AtR_conv_para = np.zeros((num_rad,num_theta,num_var_t,num_var_r))
AtR_conv_para_svd = np.zeros((num_rad,num_theta,num_var_t,num_var_r))
# Convolution
a = time.time()
AtR_conv = CO.AtR_ft_2D(B0ft_stack,R)
timeAtR = time.time() - a
a = time.time()
num_theta = 250
dtheta = 2*np.pi/num_theta
scale = [200, 400, 330]
means = [40, 140, 200]
stds = [5, 10, 7]
np.random.normal(0,1,num_theta)
noise = np.random.normal(0,1,num_theta)
signal = np.zeros(num_theta)
for i in range(3):
signal += scale[i]*EM.gaussian_basis_wrap(num_theta,
dtheta,
means[i],
(stds[i]*dtheta)**2)
#%% Create Dictionary
num_var = 15
# Local maxima
maxima = argrelmax(signal)[0]
# Variances
test_vars = np.linspace((dtheta),(np.pi/16),num_var)**2
variances = test_vars
B = np.empty([num_theta,0])
B0 = np.empty([num_theta,0])
B0_tran = np.zeros([num_theta,num_var])
reload(EM)
num_var_t = 15
num_var_r = 10
var_theta = np.linspace((dtheta), (np.pi / 32), num_var_t)**2
var_rad = np.linspace(drad, 3, num_var_r)**2
# Generate unshifted basis function for each variance combination
#Store stack of image slices
B0_stack = np.zeros((num_rad, num_theta, num_var_t, num_var_r))
for t in range(num_var_t):
for r in range(num_var_r):
m_r = 0
m_theta = 0
B0 = EM.gaussian_basis_wrap_2D(num_theta, dtheta, m_theta,
var_theta[t], num_rad, drad, m_r,
var_rad[r]).reshape(
(num_rad, num_theta))
B0_stack[:, :, t, r] = B0
B0_stack_ft = np.zeros(B0_stack.shape)
for tv in range(num_var_t):
for rv in range(num_var_r):
B0_stack_ft[:, :, tv, rv] = np.fft.fft2(B0_stack[:, :, tv, rv])
# Fit 2D data
l1_ratio = 1
max_iters = 500
#plt.figure(1)
#plt.imshow(8000*B0_stack[:,:,12,9],cmap='jet', interpolation='nearest',vmin=0,vmax=200)
#%% Plot fit but try to remove DC component
plt.figure(1)
plt.ylabel('Intensity')
plt.xlabel('Angle (Radians)')
plt.plot(rsf_ex.theta, rsf_ex.f, 'bo-')
# Construct B
dom = np.arange(len(rsf_ex.coefs))
keep = dom[np.abs(rsf_ex.coefs) > 0]
full_fit = np.zeros(len(rsf_ex.theta))
for i in keep:
if (rsf_ex.coefs[i] < 10):
basis = EM.gaussian_basis_wrap(len(rsf_ex.f), dtheta, rsf_ex.means[i],
rsf_ex.variances[i])
plt.figure(1)
plt.plot(rsf_ex.theta, rsf_ex.coefs[i] * basis, 'r-')
full_fit += rsf_ex.coefs[i] * basis
plt.plot(rsf_ex.theta, full_fit, 'g-')
#%% View an individual histogram and fit plots
num_theta = 2400
dtheta = 2 * np.pi / num_theta
num_bins = 30
img_num = 13
load_steps = [0, 4]
bar_colors = ['r', 'b', 'g', 'm', 'k']
#%% Generate Data
num_theta = 250
dtheta = 2*np.pi/num_theta
scale = [200, 400, 330]
means = [40, 140, 200]
np.random.normal(0,1,num_theta)
noise = np.random.normal(0,1,num_theta)
signal = 0
i = 1
signal += EM.gaussian_basis_wrap(num_theta,dtheta,0,(10*dtheta)**2)
coefs = np.zeros((num_theta))
for i in range(3):
coefs[means[i]] = scale[i]
import cython_test as ct
a_fft = np.fft.fft(signal)
b_fft = np.fft.fft(coefs)
# Convolution via cython and blas
t = time.time()
radius = 370
num_theta = 2048
num_rad = 2 * dr
num_var_t = 15
num_var_r = 10
dtheta = 2 * np.pi / num_theta
drad = 1
var_theta = np.linspace((dtheta), (np.pi / 32), num_var_t)**2
var_rad = np.linspace(drad, 3, num_var_r)**2
# Compute basis matrix and interpolate ring to polar coordinates
A0_stack = EM.unshifted_basis_matrix_stack(var_theta, var_rad, dtheta, drad,
num_theta, num_rad)
#%% Test individual operations
reload(CO)
a = time.time()
np.fft.fft2(A0_stack[:, :, 0, 0])
#CO.AtR_ft_2D(A0_stack, A0_stack[:,:,0,0])
print(time.time() - a)
#%% Test Algorithm
a = time.time()
CO.Ax_ft_2D(A0_stack, A0_stack)
#LassoSolvers.fista_circulant_2D(A0_stack, np.sum(np.sum(A0#_stack,2),2), 6e5, 1, 5, eps=10**(-7), positive=1, verbose=1, #benchmark=1)
print(time.time() - a)
#np.save('ringModels_synth.npy',ringModels_synth)
#%% Lasso fitting for each ring
num_var = 15
# Extract local maxima
maxima = argrelmax(b)[0]
# Create Gaussian basis function fitting matrix
test_vars = np.linspace((dtheta), (np.pi / 16), num_var)**2
variances = test_vars
B = np.empty([num_theta, 0])
B0 = np.empty([num_theta, 0])
B0_tran = np.zeros([num_theta, num_var])
for i, var in enumerate(variances):
basis_vec = EM.gaussian_basis_wrap(num_theta, dtheta, 0, var)
B0 = np.hstack([B0, basis_vec[:, None]])
for shift in maxima:
B_shift = np.concatenate([basis_vec[-shift:], basis_vec[0:-shift]])
B = np.hstack([B, B_shift[:, None]])
B_tran = np.transpose(B)
for i, var in enumerate(variances):
B0_tran[0, i] = B0[0, i]
B0_tran[1::, i] = np.flipud(B0[1::, i])
B = np.array(B, order='F', copy=True)
B_tran = np.array(B_tran, order='F', copy=True)
B0 = np.array(B0, order='F', copy=True)
B0_tran = np.array(B0_tran, order='F', copy=True)