def save_image(data, file_path):
lg.text_log('saving images as tif files')
lg.text_log(
'each image is a complex impedance parameter: frequency, magnitude, phase, Re, Im and optional baseline slope'
)
file_path_list = file_path.replace('\\', '/').split('/')
file_path = '/'.join(map(str, file_path_list[:-1]))
file_name = file_path_list[-1].split('.')[0]
img = Image.fromarray(data[0])
img.save(file_path + '/' + file_name + '_freq.tif')
img = Image.fromarray(data[1])
img.save(file_path + '/' + file_name + '_mag.tif')
img = Image.fromarray(data[2])
img.save(file_path + '/' + file_name + '_phase.tif')
img = Image.fromarray(data[3])
img.save(file_path + '/' + file_name + '_real.tif')
img = Image.fromarray(data[4])
img.save(file_path + '/' + file_name + '_imag.tif')
img = Image.fromarray(data[5])
img.save(file_path + '/' + file_name + '_inclination.tif')
def find_extrema(x, y):
lg.function_log()
lg.text_log('fit spline for algebraic operations')
y_spline = UnivariateSpline(x, y, k=4, s=0)
lg.text_log('get extrema via roots of first derivative')
d_roots = y_spline.derivative().roots()
lg.img_log((x, (curve_normalize(y), curve_normalize(
y_spline(x)), curve_normalize(y_spline.derivative()(x)))),
title='extrema calculation (normalized)',
legend=['y', 'spline fit', '1st derivative (spline)'],
x_axis='x',
y_axis='y')
lg.text_log('assign extrema via second derivative')
max_x = [x for x in d_roots if y_spline.derivative(2)(x) < 0]
min_x = [x for x in d_roots if y_spline.derivative(2)(x) > 0]
return max_x, y_spline(max_x), min_x, y_spline(min_x)
def find_extrema(x, y):
lg.function_log()
lg.text_log('fit spline for algebraic operations')
y_spline = UnivariateSpline(x, y, k=4, s=0)
"""
plt.plot(x, y, label = 'original')
plt.plot(x, y_spline(x), label = 'spline')
#plt.plot(x, y_spline.derivative()(x), label = '1st derivative')
plt.xlabel('frequency [Hz]')
plt.ylabel('magnitude')
lg.img_log('find extrema')
"""
lg.text_log('get extrema via roots of first derivative')
d_roots = y_spline.derivative().roots()
lg.text_log('assign extrema via second derivative')
max_x = [x for x in d_roots if y_spline.derivative(2)(x) < 0]
min_x = [x for x in d_roots if y_spline.derivative(2)(x) > 0]
return max_x, y_spline(max_x), min_x, y_spline(min_x)
def gauss_optimum(I):
lg.function_log()
cost_list = []
dI_list = []
d_args_list = []
sigma_factor = 0.1
sigma_range = np.arange(1*sigma_factor,len(I)*sigma_factor,sigma_factor)
I_0 = I
lg.text_log('calculate squared argsort difference for I_n-1 and I_n ')
for sigma in sigma_range:
I_gauss = gaussian_filter1d(I, sigma)
dI = sum([(a_i - b_i)**2 for a_i, b_i in zip(I_gauss, I_0)])
d_args = sum([(a_i - b_i)**2 for a_i, b_i in zip(np.argsort(I_gauss), np.argsort(I_0))])
cost = d_args*dI
I_0 = I_gauss
cost_list.append(cost)
dI_list.append(dI)
d_args_list.append(d_args)
#plt.plot(sigma_range, d_args_list, label = 'd_args')
#lg.img_log('argsort difference raw')
#lg.text_log('set initial d_args peak parameters')
Amp_init = d_args_list[np.argsort(d_args_list)[-1]]
cen_init = sigma_range[np.argsort(d_args_list)[-1]]
sigma_init = abs(cen_init-sigma_range[0])
p_Amp = [Amp_init, 0, Amp_init*1.2]
p_cen = [cen_init, 0, cen_init*2]
p_sigma = [sigma_init, sigma_init*0.01, sigma_init*5]
params, bnds = lg.var_log(fit_params((p_Amp, p_sigma, p_cen)))
#lg.text_log('fit gauss peak to extract optimum sigma')
gauss_peak_params, gauss_peak_errs = curve_fit(gauss_peak, sigma_range, d_args_list, p0=params, bounds=bnds)
#lg.var_log(gauss_peak_params)
#plt.plot(sigma_range, d_args_list, label = 'd_args')
d_args_list = gauss_peak(sigma_range, *gauss_peak_params)
#plt.plot(sigma_range, d_args_list, label = 'gauss peak fit')
#plt.xlabel('sigma')
#plt.ylabel('d_args')
#lg.img_log('argsort difference peak fit')
#lg.text_log('get optimum sigma for gauss filtering from maximum argsort difference')
sigma_optimum = lg.var_log(gauss_peak_params[2]+abs(gauss_peak_params[1]))
#lg.text_log('calculated new filtered spectrum')
I_optimum = gaussian_filter1d(I, sigma_optimum)
#documentation plot
#plt.plot(I, label='original')
#plt.plot(I_optimum, label='sigma optimum')
#plt.xlabel('n')
#plt.ylabel('magnitude')
#lg.img_log('gauss_filtering')
return I_optimum
def image_fft(window_size, file_path, dt, frequency=None):
#load image
lg.text_log('loading raw image stack')
im = io.imread(file_path)
#correction in case window size is set larger the image size
window_size = min(window_size, im.shape[1] - 1, im.shape[2] - 1)
#get image dimensions
x_dim = (im.shape[1] - window_size)
y_dim = (im.shape[2] - window_size)
z_dim = im.shape[0]
#create arrays to iterate over
x_range = np.arange(0, x_dim)
#x_range = np.arange(0,2)
y_range = np.arange(0, y_dim)
z_range = np.arange(0, z_dim)
#create empty result matrix to store the calculated values
result = np.empty((6, x_dim, y_dim))
#total dimensions for measurement of calculation progress
n_total = x_dim * y_dim * z_dim
#count for estimation of calculation progress
count = 0
#iteration over all pixels (x,y) and slides z
print('start calculation...')
start_time = datetime.now()
elapsed_time = datetime.now() - start_time
t_log = open(file_path[:-4] + '_progress_log.txt', "w")
t_log.write('total dimensions: ' + str(n_total) + '\n')
lg.text_log('calculate fourier transform for each pixel')
lg.text_log(
'the mean intensity for each pixel with a defined window size (x^2) is calculated'
)
for x in x_range:
if count == 0:
remaining_time = ''
else:
remaining_time = str(
timedelta(seconds=(elapsed_time.seconds / count *
(n_total - count))))
progress = np.round((count / n_total * 100), 1)
print(str(progress) + ' % done. remaining: ' + remaining_time)
t_log.write(
str(elapsed_time.seconds) + '\t' + remaining_time + '\t' +
str(elapsed_time.seconds / max(count, 1)) + '\n')
for y in y_range:
#signal array to store the mean value of the window
signal_array = []
#print progress
for z in z_range:
#collecting all pixel values in the window
img_slice = im[z]
rows = img_slice[x:x + window_size]
full_array = []
for item in rows:
full_array = full_array + list(item[y:y + window_size])
#append mean values to signal array
signal_array.append(np.mean(full_array))
#count for estimation of calculation progress
count = count + 1
elapsed_time = datetime.now() - start_time
#baseline and its inclination
lg.text_log('optional baseline calculation and correction')
"""
base, inclination = baseline(dt, signal_array)
lg.img_log((fourier_transform(dt, signal_array)[0],
(np.abs(fourier_transform(dt, signal_array)[1]), np.abs(fourier_transform(dt, signal_array-base)[1]))),
title='baseline subtraction impact', legend=['raw','baseline subtracted'],
x_axis='frequency [Hz]', y_axis='Magnitude A.U.')
signal_array = signal_array-base
"""
#calculate fourier parameters of baseline corrected signal
lg.text_log(
'get complex impedance parameters from fourier transform:')
freq, mag, phase, real, imag = fourier_params(
dt, signal_array, frequency)
#write results to corresponding image slides
result[0, x, y] = freq
result[1, x, y] = mag
result[2, x, y] = phase
result[3, x, y] = real
result[4, x, y] = imag
#result[5,x,y]= inclination
t_log.close()
return result