def error_measurement(self, res_prev, iter): if self.Quameasopts is not None and iter > 0: self.lq.append(MQ(self.res, res_prev, self.Quameasopts)) if self.computel2: # compute l2 borm for b-Ax errornow = im3DNORM(self.proj - Ax(self.res, self.geo, self.angles, 'ray-voxel'), 2) self.l2l.append(errornow)
def __init__(self, proj, geo, angles, niter, **kwargs): if "blocksize" not in kwargs: kwargs.update(blocksize=1) IterativeReconAlg.__init__(self, proj, geo, angles, niter, **kwargs) if "alpha" not in kwargs: self.alpha = 0.002 if "alpha_red" not in kwargs: self.alpha_red = 0.95 if "rmax" not in kwargs: self.rmax = 0.95 if "maxl2err" not in kwargs: self.epsilon = ( im3DNORM(Ax(FDK(proj, geo, angles, gpuids=self.gpuids), geo, angles) - proj, 2) * 0.2 ) else: self.epsilon = kwargs["maxl2err"] if "tviter" not in kwargs: self.numiter_tv = 20 else: self.numiter_tv = kwargs["tviter"] if "regularisation" not in kwargs: self.regularisation = "minimizeTV" self.beta = self.lmbda self.beta_red = self.lmbda_red
def run_main_iter(self): stop_criteria = False n_iter = 0 while not stop_criteria: if self.verbose: if n_iter == 0: print("POCS Algorithm in progress.") toc = default_timer() if n_iter == 1: tic = default_timer() remaining_time = (self.niter - 1) * (tic - toc) seconds = int(remaining_time) print("Estimated time until completion : " + time.strftime("%H:%M:%S", time.gmtime(seconds))) res_prev = copy.deepcopy(self.res) n_iter += 1 getattr(self, self.dataminimizing)() g = Ax(self.res, self.geo, self.angles, gpuids=self.gpuids) dd = im3DNORM(g - self.proj, 2) dp_vec = self.res - res_prev dp = im3DNORM(dp_vec, 2) if n_iter == 1: dtvg = self.alpha * dp res_prev = copy.deepcopy(self.res) self.res = getattr(self, self.regularisation)(self.res, dtvg) dg_vec = self.res - res_prev dg = im3DNORM(dg_vec, 2) if dg > self.rmax * dp and dd > self.epsilon: dtvg = dtvg * self.alpha_red self.beta *= self.beta_red c = np.dot(dg_vec.reshape(-1, ), dp_vec.reshape(-1, )) / max( dg * dp, 1e-6) # reshape ensures no copy is made. if (c < -0.99 and dd <= self.epsilon ) or self.beta < 0.005 or n_iter > self.niter: if self.verbose: print("\n" " Stop criteria met: \n" " c = " + str(c) + "\n" " beta = " + str(self.beta) + "\n" " iter = " + str(n_iter) + "\n") stop_criteria = True
def error_measurement(self, res_prev, iter): if self.Quameasopts is not None: self.lq[:, iter] = MQ(self.res, res_prev, self.Quameasopts) if self.computel2: # compute l2 borm for b-Ax errornow = im3DNORM( self.proj - Ax(self.res, self.geo, self.angles, "Siddon", gpuids=self.gpuids), 2 ) self.l2l[0, iter] = errornow
def run_main_iter(self): stop_criteria = False n_iter = 0 while not stop_criteria: if self.verbose: if n_iter == 0: print("POCS Algorithm in progress.") toc = time.clock() if n_iter == 1: tic = time.clock() print('Esitmated time until completetion (s): ' + str((self.niter - 1) * (tic - toc))) res_prev = copy.deepcopy(self.res) n_iter += 1 getattr(self, self.dataminimizing)() g = Ax(self.res, self.geo, self.angles) dd = im3DNORM(g - self.proj, 2) dp_vec = self.res - res_prev dp = im3DNORM(dp_vec, 2) if n_iter == 1: dtvg = self.alpha * dp res_prev = copy.deepcopy(self.res) self.res = getattr(self, self.regularisation)(self.res, dtvg) dg_vec = self.res - res_prev dg = im3DNORM(dg_vec, 2) if dg > self.rmax * dp and dd > self.epsilon: dtvg = dtvg * self.alpha_red self.beta *= self.beta_red c = np.dot(dg_vec.reshape(-1, ), dp_vec.reshape(-1, )) / max( dg * dp, 1e-6) if (c < -0.99 and dd <= self.epsilon ) or self.beta < 0.005 or n_iter > self.niter: if self.verbose: print("\n" " Stop criteria met: \n" " c = " + str(c) + "\n" " beta = " + str(self.beta) + "\n" " iter = " + str(n_iter)) + "\n" stop_criteria = True
def run_main_iter(self): stop_criteria = False n_iter = 0 while not stop_criteria: if self.verbose: self._estimate_time_until_completion(n_iter) res_prev = copy.deepcopy(self.res) getattr(self, self.dataminimizing)() if self.Quameasopts is not None: self.error_measurement(res_prev, n_iter) n_iter += 1 g = Ax(self.res, self.geo, self.angles, gpuids=self.gpuids) dd = im3DNORM(g - self.proj, 2) dp_vec = self.res - res_prev dp = im3DNORM(dp_vec, 2) if n_iter == 1: dtvg = self.alpha * dp res_prev = copy.deepcopy(self.res) self.res = getattr(self, self.regularisation)(self.res, dtvg) dg_vec = self.res - res_prev dg = im3DNORM(dg_vec, 2) if dg > self.rmax * dp and dd > self.epsilon: dtvg = dtvg * self.alpha_red self.beta *= self.beta_red c = np.dot(dg_vec.reshape(-1,), dp_vec.reshape(-1,)) / max( dg * dp, 1e-6 ) # reshape ensures no copy is made. if (c < -0.99 and dd <= self.epsilon) or self.beta < 0.005 or n_iter >= self.niter: if self.verbose: print( "\n" " Stop criteria met: \n" " c = " + str(c) + "\n" " beta = " + str(self.beta) + "\n" " iter = " + str(n_iter) + "\n" ) stop_criteria = True
def run_main_iter(self): stop_criteria = False n_iter = 0 while not stop_criteria: if self.verbose: if n_iter == 0: print("POCS Algorithm in progress.") toc = time.clock() if n_iter == 1: tic = time.clock() print('Esitmated time until completetion (s): ' + str((self.niter - 1) * (tic - toc))) res_prev = copy.deepcopy(self.res) n_iter += 1 getattr(self, self.dataminimizing)() g = Ax(self.res, self.geo, self.angles) dd = im3DNORM(g-self.proj, 2) dp_vec = self.res - res_prev dp = im3DNORM(dp_vec, 2) if n_iter == 1: dtvg = self.alpha * dp res_prev = copy.deepcopy(self.res) self.res = getattr(self, self.regularisation)(self.res, dtvg) dg_vec = self.res - res_prev dg = im3DNORM(dg_vec, 2) if dg > self.rmax*dp and dd > self.epsilon: dtvg = dtvg*self.alpha_red self.beta *= self.beta_red c = np.dot(dg_vec.reshape(-1,), dp_vec.reshape(-1,))/max(dg*dp, 1e-6) if (c < -0.99 and dd <= self.epsilon) or self.beta < 0.005 or n_iter > self.niter: if self.verbose: print("\n" " Stop criteria met: \n" " c = " + str(c) + "\n" " beta = " + str(self.beta) + "\n" " iter = " + str(n_iter)) + "\n" stop_criteria = True
def run_main_iter(self): stop_criteria = False n_iter = 0 d_p_1st = 1 while not stop_criteria: if self.verbose: self._estimate_time_until_completion(n_iter) res_prev = copy.deepcopy(self.res) n_iter += 1 est_proj = Ax(self.res, self.geo, self.angles) d_p = im3DNORM(est_proj - self.proj, 2) if d_p**2 > self.epsilon: getattr(self, self.dataminimizing)() dd = im3DNORM(Ax(self.res,self.geo,self.angles)-self.proj, 2) dp_vec = self.res - res_prev dp = im3DNORM(dp_vec, 2) dtvg = 1 if n_iter == 1 else d_p / d_p_1st res_prev = copy.deepcopy(self.res) self.res = getattr(self, self.regularisation)(self.res, dtvg) dg_vec = self.res - res_prev dg = im3DNORM(dg_vec, 2) if n_iter == 1: d_p_1st = im3DNORM(Ax(res_prev,self.geo,self.angles)-self.proj, 2) self.beta *= self.beta_red c = np.dot(dg_vec.reshape(-1,), dp_vec.reshape(-1,)) / max(dg * dp, 1e-6) # reshape ensures no copy is made. if (c < -0.99 and dd <= self.epsilon) or self.beta < 0.005 or n_iter > self.niter: if self.verbose: print("\n" " Stop criteria met: \n" " c = " + str(c) + "\n" " beta = " + str(self.beta) + "\n" " iter = " + str(n_iter) + "\n") stop_criteria = True
def error_measurement(self, res_prev, iter): if self.Quameasopts is not None and iter > 0: self.lq.append( Measure_Quality(self.res, res_prev, self.Quameasopts)) if self.computel2: # compute l2 borm for b-Ax errornow = im3DNORM( self.proj - Ax(self.res, self.geo, self.angles, "Siddon", gpuids=self.gpuids), 2) self.l2l.append(errornow)
def __init__(self, proj, geo, angles, niter, **kwargs): # if "blocksize" not in kwargs: # kwargs.update(dict(blocksize=1)) #kwargs.update(dict(regularisation="minimizeTV")) IterativeReconAlg.__init__(self, proj, geo, angles, niter, **kwargs) if "maxl2err" not in kwargs: self.epsilon = ( im3DNORM(Ax(FDK(proj, geo, angles, gpuids=self.gpuids), geo, angles) - proj, 2) * 0.2 ) else: self.epsilon = kwargs["maxl2err"] self.numiter_tv = 20 if "tviter" not in kwargs else kwargs["tviter"] self.beta = self.lmbda self.beta_red = self.lmbda_red
def __init__(self, proj, geo, angles, niter, **kwargs): IterativeReconAlg.__init__(self, proj, geo, angles, niter, **kwargs) if not kwargs.has_key('alpha'): self.alpha = 0.002 if not kwargs.has_key('alpha_red'): self.alpha_red = 0.95 if not kwargs.has_key('rmax'): self.rmax = 0.95 if not kwargs.has_key('maxl2err'): self.epsilon = im3DNORM(FDK(proj, geo, angles), 2) * 0.2 if not kwargs.has_key("numiter_tv"): self.numiter_tv = 20 if not kwargs.has_key('regularisation'): self.regularisation = 'minimizeTV' self.beta = self.lmbda self.beta_red = self.lmbda_red
def __init__(self, proj, geo, angles, niter, **kwargs): if 'blocksize' not in kwargs: kwargs.update(blocksize=1) IterativeReconAlg.__init__(self, proj, geo, angles, niter, **kwargs) if 'alpha' not in kwargs: self.alpha = 0.002 if 'alpha_red' not in kwargs: self.alpha_red = 0.95 if 'rmax' not in kwargs: self.rmax = 0.95 if 'maxl2err' not in kwargs: self.epsilon = im3DNORM(FDK(proj, geo, angles), 2) * 0.2 if "numiter_tv" not in kwargs: self.numiter_tv = 20 if 'regularisation' not in kwargs: self.regularisation = 'minimizeTV' self.beta = self.lmbda self.beta_red = self.lmbda_red
def __init__(self, proj, geo, angles, niter, **kwargs): if 'blocksize' not in kwargs: kwargs.update(blocksize=1) IterativeReconAlg.__init__(self, proj, geo, angles, niter, **kwargs) if 'alpha' not in kwargs: self.alpha = 0.002 if 'alpha_red' not in kwargs: self.alpha_red = 0.95 if 'rmax' not in kwargs: self.rmax = 0.95 if 'maxl2err' not in kwargs: self.epsilon = im3DNORM(FDK(proj, geo, angles), 2)*0.2 if "numiter_tv" not in kwargs: self.numiter_tv = 20 if 'regularisation' not in kwargs: self.regularisation = 'minimizeTV' self.beta = self.lmbda self.beta_red = self.lmbda_red
# # ASD-POCS has a veriety of optional arguments, and some of them are crucial # to determine the behaviour of the algorithm. The advantage of ASD-POCS is # the power to create good images from bad data, but it needs a lot of # tunning. # # Optional parameters that are very relevant: # ---------------------------------------------- # 'maxL2err' Maximum L2 error to accept an image as valid. This # parameter is crucial for the algorithm, determines at # what point an image should not be updated further. # Default is 20% of the FDK L2 norm. # # its called epsilon in the paper epsilon = ( im3DNORM(tigre.Ax(algs.fdk(noise_projections, geo, angles), geo, angles) - noise_projections, 2) * 0.15 ) # 'alpha': Defines the TV hyperparameter. default is 0.002. # However the paper mentions 0.2 as good choice alpha = 0.002 # 'tviter': Defines the amount of TV iterations performed per SART # iteration. Default is 20 ng = 25 # Other optional parameters # ---------------------------------------------- # 'lambda': Sets the value of the hyperparameter for the SART iterations. # Default is 1