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 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