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