def __init__(self, data, metadata,
background=None, noise_sigma=None):
self.data = data.squeeze()
self.background = background
self.noise_sigma = noise_sigma
self.sigma_is_scalar = not len(np.shape(noise_sigma)) > 1
self.metadata = metadata
self.fit_fcn = fast_gauss
ado = np.float32(self.metadata.Camera.ADOffset)
am = cl.mem_access_mode
hm = cl.mem_host_ptr_mode
# region : Data pre-processing
if ado != 0:
self.data -= ado
# endregion : Data pre-processing
# region : Background pre-processing
pp1 = self.background is not None
pp2 = len(np.shape(background)) > 1
pp3 = 'Analysis.subtractBackground' in \
self.metadata.getEntryNames() and \
self.metadata.Analysis.subtractBackground is False
if pp1 and pp2 and not pp3:
self.background = self.background.squeeze() - ado
else:
self.background = 0
# endregion : Background pre-processing
# region : Noise sigma pre-processing
if self.noise_sigma is None:
self.noise_sigma = \
np.sqrt(self.metadata.Camera.ReadNoise ** 2 +
(self.metadata.Camera.NoiseFactor ** 2) *
self.metadata.Camera.ElectronsPerCount *
self.metadata.Camera.TrueEMGain *
(np.maximum(data, 1) + 1)) / \
self.metadata.Camera.ElectronsPerCount
if not self.sigma_is_scalar:
self.noise_sigma = self.noise_sigma.squeeze()
# > initialize sigma in device
cl.sigma = cl.create_buffer(am.READ_ONLY,
hostbuf=self.noise_sigma,
host_ptr_mode=hm.COPY_HOST_PTR)
# endregion : Noise sigma pre-processing
# region : Initialize data in device
# TODO
'''Use 'data = data - bkg' to save space for data_mean,
A (= data.max() - data.min()) in start parameter will be
affected'''
self.data_mean = self.data - self.background
cl.data = cl.create_buffer(am.READ_ONLY,
hostbuf=self.data_mean,
host_ptr_mode=hm.COPY_HOST_PTR)
# endregion : Initialize data in device
pass
# > create OpenCL context
cl.create_context()
# > create and build program on context
cl.compile_link_program(kernel_headers, kernel_sources)
print('-=> dip.ip initialized')
# endregion : Initialize CL
# region : Self-test
if __name__ == '__main__':
import numpy as np
x = np.zeros((2, 2), np.int32)
x[0, 0] = 800
x[0, 1] = 801
x[1, 0] = 810
x[1, 1] = 811
print x.flatten()
print x.size
x_buf = cl.create_buffer(cl.am.READ_ONLY, x.nbytes)
x_buf.enqueue_write(x)
cl.program.test(4, x_buf)
# endregion : Self-test
kernel_sources += '/* ' + f + ' */\n'
kernel_sources += open(path + f).read() + '\n'
# endregion : Load kernel sources
# region : Initialize CL
# > create OpenCL context
cl.create_context()
# > create and build program on context
cl.create_build_program(kernel_sources)
print('-=> dip.ip initialized')
# endregion : Initialize CL
# region : Self-test
if __name__ == '__main__':
import numpy as np
x = np.zeros((2, 2))
buf = cl.create_buffer(cl.mem_access_mode.READ_WRITE,
hostbuf=x, host_ptr_mode=
cl.mem_host_ptr_mode.COPY_HOST_PTR)
cl.program.test_2(x.shape, (buf,))
# cl.program.cl_test((2, 2, 1), (np.int32(8),))
# endregion : Self-test
def __init__(self, data, metadata, background=None, noise_sigma=None):
self.data = data.squeeze()
self.background = background
self.noise_sigma = noise_sigma
self.sigma_is_scalar = not len(np.shape(noise_sigma)) > 1
self.metadata = metadata
self.fit_fcn = fast_gauss
ado = np.float32(self.metadata.Camera.ADOffset)
am = cl.mem_access_mode
hm = cl.mem_host_ptr_mode
# region : Data pre-processing
if ado != 0:
self.data -= ado
# endregion : Data pre-processing
# region : Background pre-processing
pp1 = self.background is not None
pp2 = len(np.shape(background)) > 1
pp3 = 'Analysis.subtractBackground' in \
self.metadata.getEntryNames() and \
self.metadata.Analysis.subtractBackground is False
if pp1 and pp2 and not pp3:
self.background = self.background.squeeze() - ado
else:
self.background = 0
# endregion : Background pre-processing
# region : Noise sigma pre-processing
if self.noise_sigma is None:
self.noise_sigma = \
np.sqrt(self.metadata.Camera.ReadNoise ** 2 +
(self.metadata.Camera.NoiseFactor ** 2) *
self.metadata.Camera.ElectronsPerCount *
self.metadata.Camera.TrueEMGain *
(np.maximum(data, 1) + 1)) / \
self.metadata.Camera.ElectronsPerCount
if not self.sigma_is_scalar:
self.noise_sigma = self.noise_sigma.squeeze()
# > initialize sigma in device
cl.sigma = cl.create_buffer(am.READ_ONLY,
hostbuf=self.noise_sigma,
host_ptr_mode=hm.COPY_HOST_PTR)
# endregion : Noise sigma pre-processing
# region : Initialize data in device
# TODO
'''Use 'data = data - bkg' to save space for data_mean,
A (= data.max() - data.min()) in start parameter will be
affected'''
self.data_mean = self.data - self.background
cl.data = cl.create_buffer(am.READ_ONLY,
hostbuf=self.data_mean,
host_ptr_mode=hm.COPY_HOST_PTR)
# endregion : Initialize data in device
pass
def FromPoint(self, x, y, roi_half_size=5):
# > get ROI [3.0%]
# --------------------------------------------------------------
# region : STD
x_r = round(x)
y_r = round(y)
xslice = slice(max((x_r - roi_half_size), 0),
min((x_r + roi_half_size + 1), self.data.shape[0]))
yslice = slice(max((y_r - roi_half_size), 0),
min((y_r + roi_half_size + 1), self.data.shape[1]))
data = self.data[xslice, yslice]
X = 1e3 * self.metadata.voxelsize.x * np.mgrid[xslice]
Y = 1e3 * self.metadata.voxelsize.y * np.mgrid[yslice]
# estimate errors in data
sigma = self.noise_sigma
if not self.sigma_is_scalar:
sigma = self.noise_sigma[xslice, yslice]
data_mean = self.data_mean[xslice, yslice]
# endregion : STD
# > estimate some start parameters
# --------------------------------------------------------------
# TODO
'''Changing A will lead to large delta of final A and sigma'''
# A = data_mean.max() - data_mean.min() # amplitude
A = data.max() - data.min() # amplitude
x0 = 1e3 * self.metadata.voxelsize.x * x
y0 = 1e3 * self.metadata.voxelsize.y * y
start_parameters = np.asarray(
[A, x0, y0, 250 / 2.35,
data_mean.min(), .001, .001], np.float64)
# > send data to device
# TODO: set to CL scope temporarily
# >> X
cl.X = cl.create_buffer(cl.am.READ_ONLY, X.nbytes)
cl.X.enqueue_write(X)
# >> Y
cl.Y = cl.create_buffer(cl.am.READ_ONLY, Y.nbytes)
cl.Y.enqueue_write(Y)
# >> x0
cl.x0 = cl.create_buffer(cl.am.READ_WRITE, start_parameters.nbytes)
cl.x0.enqueue_write(start_parameters)
# >> wa
wa = np.array([self.data_mean.shape[1], 0], np.int32)
cl.wa = cl.create_buffer(cl.am.READ_WRITE, wa.nbytes)
cl.wa.enqueue_write(wa)
# > do the fit
# --------------------------------------------------------------
if False:
L = X.size
m = L * L
n = 7
filename = r'latgauss_export.data'
if 'NOT_FIRST_TIME' in self.__dict__:
f = open(filename, 'a')
else:
f = open(filename, 'w')
# > write img
img = np.asarray(self.data_mean, np.float64).flatten()
for i in range(img.size):
f.write('%.16f\n' % img[i])
# > write sigma
img_sig = np.asarray(self.noise_sigma, np.float64).flatten()
for i in range(img_sig.size):
f.write('%s.16f\n' % img_sig[i])
self.NOT_FIRST_TIME = True
# > write X
for i in range(L):
f.write('%f\n' % X[i])
# > write Y
for i in range(L):
f.write('%f\n' % Y[i])
# > write y
for i in range(L):
for j in range(L):
f.write('%f\n' % data_mean[i, j])
# > write sigma
for i in range(L):
for j in range(L):
f.write('%.16f\n' % sigma[i, j])
# > write x0
for i in range(n):
f.write('%.16f\n' % start_parameters[i])
# > close
f.close()
(res, cov_x, info_dict, msg,
res_code) = fit_model_weighted(self.fit_fcn, start_parameters,
data_mean, sigma, X, Y)
# > try to estimate errors based on the covariance matrix
# --------------------------------------------------------------
fit_errors = None
bg_mean = 0
try:
bg_mean = np.linalg.norm(info_dict['fvec'])
fit_errors = np.sqrt(
np.diag(cov_x) *
(info_dict['fvec'] * info_dict['fvec']).sum() /
(len(data_mean.ravel()) - len(res)))
except Exception:
pass
# print('!!! Failed to estimate errors based on the
# covariance matrix')
# > package results
# --------------------------------------------------------------
return GaussianFitResultR(res, self.metadata,
(xslice, yslice, slice(0, 1, None)),
res_code, fit_errors, bg_mean)
# endregion : Load kernel sources
# region : Initialize CL
# > create OpenCL context
cl.create_context()
# > create and build program on context
cl.compile_link_program(kernel_headers, kernel_sources)
print('-=> dip.ip initialized')
# endregion : Initialize CL
# region : Self-test
if __name__ == '__main__':
import numpy as np
x = np.zeros((2, 2), np.int32)
x[0, 0] = 800
x[0, 1] = 801
x[1, 0] = 810
x[1, 1] = 811
print x.flatten()
print x.size
x_buf = cl.create_buffer(cl.am.READ_ONLY, x.nbytes)
x_buf.enqueue_write(x)
cl.program.test(4, x_buf)
# endregion : Self-test
