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 update_image(self, geo, angle, iteration):
"""
VERBOSE:
for j in range(angleblocks):
angle = np.array([alpha[j]], dtype=np.float32)
proj_err = proj[angle_index[j]] - Ax(res, geo, angle, 'Siddon')
weighted_err = W[angle_index[j]] * proj_err
backprj = Atb(weighted_err, geo, angle, 'FDK')
weighted_backprj = 1 / V[angle_index[j]] * backprj
res += weighted_backprj
res[res<0]=0
:return: None
"""
ang_index = self.angle_index[iteration].astype(np.int)
self.res += (
self.lmbda
* 1.0
/ self.V[iteration]
* Atb(
self.W[ang_index]
* (self.proj[ang_index] - Ax(self.res, geo, angle, "Siddon", gpuids=self.gpuids)),
geo,
angle,
"FDK",
gpuids=self.gpuids,
)
)
def run_main_iter(self):
self.res[self.res < 0.] = 0.
for i in range(self.niter):
if i == 0:
if self.verbose:
print("MLEM Algorithm in progress.")
toc = default_timer()
if i == 1:
tic = default_timer()
if self.verbose:
print(
'Esitmated time until completetion (s): {:.4f}'.format(
(self.niter - 1) * (tic - toc)))
# tic = time.process_time()
den = Ax(self.res, self.geo, self.angles, 'interpolated')
# toc = time.process_time()
# print('Ax time: {}'.format(toc-tic))
den[den == 0.] = np.inf
auxmlem = self.proj / den
# auxmlem[auxmlem == np.nan] = 0.
# auxmlem[auxmlem == np.inf] = 0.
# update
# tic = time.process_time()
img = Atb(auxmlem, self.geo, self.angles) / self.W
# toc = time.process_time()
# print('Atb time: {}'.format(toc-tic))
# img[img == np.nan] = 0.
# img[img == np.inf] = 0.
self.res = self.res * img
self.res[self.res < 0.] = 0.
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):
self.res[self.res < 0.0] = 0.0
for i in range(self.niter):
self._estimate_time_until_completion(i)
den = Ax(self.res,
self.geo,
self.angles,
"interpolated",
gpuids=self.gpuids)
# toc = time.process_time()
# print('Ax time: {}'.format(toc-tic))
den[den == 0.0] = np.inf
auxmlem = self.proj / den
# auxmlem[auxmlem == np.nan] = 0.
# auxmlem[auxmlem == np.inf] = 0.
# update
# tic = time.process_time()
img = Atb(auxmlem,
self.geo,
self.angles,
backprojection_type="matched",
gpuids=self.gpuids) / self.W
# toc = time.process_time()
# print('Atb time: {}'.format(toc-tic))
# img[img == np.nan] = 0.
# img[img == np.inf] = 0.
self.res = self.res * img
self.res[self.res < 0.0] = 0.0
def __init__(self, proj, geo, angles, niter, **kwargs):
# Don't precompute V and W.
kwargs.update(dict(W=None, V=None))
kwargs.update(dict(blocksize=angles.shape[0]))
self.log_parameters = False
self.re_init_at_iteration = 0
IterativeReconAlg.__init__(self, proj, geo, angles, niter, **kwargs)
if self.log_parameters:
parameter_history = {}
iterations = self.niter
parameter_history['alpha'] = np.zeros([iterations],
dtype=np.float32)
parameter_history['beta'] = np.zeros([iterations],
dtype=np.float32)
parameter_history['gamma'] = np.zeros([iterations],
dtype=np.float32)
parameter_history['q_norm'] = np.zeros([iterations],
dtype=np.float32)
parameter_history['s_norm'] = np.zeros([iterations],
dtype=np.float32)
self.parameter_history = parameter_history
self.__r__ = self.proj - \
Ax(self.res, self.geo, self.angles, 'Siddon', gpuids = self.gpuids)
self.__p__ = Atb(self.__r__, self.geo, self.angles, gpuids=self.gpuids)
p_norm = np.linalg.norm(self.__p__.ravel(), 2)
self.__gamma__ = p_norm * p_norm
def run_main_iter(self):
self.res[self.res < 0.0] = 0.0
for i in range(self.niter):
if self.Quameasopts is not None:
res_prev = copy.deepcopy(self.res)
self._estimate_time_until_completion(i)
den = Ax(self.res,
self.geo,
self.angles,
"interpolated",
gpuids=self.gpuids)
den[den == 0.0] = np.inf
auxmlem = self.proj / den
# update
img = Atb(auxmlem,
self.geo,
self.angles,
backprojection_type="matched",
gpuids=self.gpuids) / self.W
self.res = self.res * img
self.res[self.res < 0.0] = 0.0
if self.Quameasopts is not None:
self.error_measurement(res_prev, i)
def run_main_iter(self):
self.l2l = np.zeros([self.niter], dtype=np.float32)
for i in range(self.niter):
if i == 0:
print("CGLS Algorithm in progress.")
toc = time.clock()
if i == 1:
tic = time.clock()
print('Esitmated time until completetion (s): ' + str((self.niter - 1) * (tic - toc)))
q = Ax(self._p, self.geo, self.angles, 'ray-voxel')
q_norm = np.linalg.norm(q.ravel(), 2)
alpha = self._gamma / (q_norm * q_norm)
self.res += alpha * self._p
error = False
for item in self.__dict__:
if type(getattr(self,item)) == np.ndarray:
if np.isnan(getattr(self,item)).any():
print(item, i)
error = True
if error:
break
aux = self.proj - Ax(self.res, self.geo, self.angles, 'ray-voxel')
self.l2l[i] = np.linalg.norm(aux.ravel(), 2)
if i > 0 and self.l2l[i] > self.l2l[i - 1]:
print('re-initialization was called at iter:' + str(i))
self.res -= alpha * self._p
self.initialise_cgls()
self._r -= alpha * q
s = Atb(self._r, self.geo, self.angles)
s_norm = np.linalg.norm(s.ravel(), 2)
gamma1 = s_norm * s_norm
beta = gamma1 / self._gamma
if self.log_parameters:
self.parameter_history['alpha'][i] = alpha
self.parameter_history['beta'][i] = beta
self.parameter_history['gamma'][i] = self._gamma
self.parameter_history['q_norm'][i] = q_norm
self.parameter_history['s_norm'][i] = s_norm
self._gamma = gamma1
self._p = s + beta * self._p
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 reinitialise_cgls(self):
self.__r__ = self.proj - Ax(
self.res, self.geo, self.angles, "Siddon", gpuids=self.gpuids)
self.__p__ = Atb(self.__r__,
self.geo,
self.angles,
backprojection_type="matched",
gpuids=self.gpuids)
p_norm = np.linalg.norm(self.__p__.ravel(), 2)
self.__gamma__ = p_norm * p_norm
def run_main_iter(self):
self.l2l = np.zeros([self.niter], dtype=np.float32)
for i in range(self.niter):
if i == 0:
print("CGLS Algorithm in progress.")
toc = time.clock()
if i == 1:
tic = time.clock()
print('Esitmated time until completetion (s): ' + str((self.niter - 1) * (tic - toc)))
q = Ax(self.__p__, self.geo, self.angles, 'ray-voxel')
q_norm = np.linalg.norm(q.ravel(), 2)
alpha = self.__gamma__ / (q_norm * q_norm)
self.res += alpha * self.__p__
for item in self.__dict__:
if type(getattr(self, item)) == np.ndarray:
if np.isnan(getattr(self, item)).any():
raise ValueError('nan found for ' + item + ' at iteraton ' + str(i))
aux = self.proj - Ax(self.res, self.geo, self.angles, 'ray-voxel')
self.l2l[i] = np.linalg.norm(aux.ravel(), 2)
if i > 0 and self.l2l[i] > self.l2l[i - 1]:
print('re-initialization was called at iter:' + str(i))
self.res -= alpha * self.__p__
self.reinitialise_cgls()
self.__r__ -= alpha * q
s = Atb(self.__r__, self.geo, self.angles)
s_norm = np.linalg.norm(s.ravel(), 2)
gamma1 = s_norm * s_norm
beta = gamma1 / self.__gamma__
if self.log_parameters:
self.parameter_history['alpha'][i] = alpha
self.parameter_history['beta'][i] = beta
self.parameter_history['gamma'][i] = self.__gamma__
self.parameter_history['q_norm'][i] = q_norm
self.parameter_history['s_norm'][i] = s_norm
self.__gamma__ = gamma1
self.__p__ = s + beta * self.__p__
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 set_w(self):
"""
Calculates value of W if this is not given.
:return: None
"""
geox = copy.deepcopy(self.geo)
geox.sVoxel[0:] = self.geo.DSD - self.geo.DSO
geox.sVoxel[2] = max(geox.sDetector[1], geox.sVoxel[2])
geox.nVoxel = np.array([2, 2, 2])
geox.dVoxel = geox.sVoxel / geox.nVoxel
W = Ax(np.ones(geox.nVoxel, dtype=np.float32), geox, self.angles, "ray-voxel")
W[W < min(self.geo.dVoxel / 4)] = np.inf
W = 1./W
setattr(self, 'W', W)
def update_image(self, geo, angle, iteration):
"""
VERBOSE:
for j in range(angleblocks):
angle = np.array([alpha[j]], dtype=np.float32)
proj_err = proj[angle_index[j]] - Ax(res, geo, angle, 'ray-voxel')
weighted_err = W[angle_index[j]] * proj_err
backprj = Atb(weighted_err, geo, angle, 'FDK')
weighted_backprj = 1 / V[angle_index[j]] * backprj
res += weighted_backprj
res[res<0]=0
:return: None
"""
self.res += self.lmbda * 1. / self.V[iteration] * Atb(self.W[self.angle_index[iteration]] * (
self.proj[self.angle_index[iteration]] - Ax(self.res, geo, angle, 'interpolated')), geo, angle, 'FDK')
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 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 set_w(self):
"""
Calculates value of W if this is not given.
:return: None
"""
geox = copy.deepcopy(self.geo)
geox.sVoxel[1:] = geox.sVoxel[
1:] * 1.1 # a bit larger to avoid zeros in projections
geox.sVoxel[0] = max(geox.sDetector[0], geox.sVoxel[0])
geox.nVoxel = np.array([2, 2, 2])
geox.dVoxel = geox.sVoxel / geox.nVoxel
W = Ax(np.ones(geox.nVoxel, dtype=np.float32), geox, self.angles,
"Siddon")
W[W <= min(self.geo.dVoxel / 4)] = np.inf
W = 1. / W
setattr(self, 'W', W)
def setUp(self):
geo = geometry()
geo.DSD = 1536
geo.DSO = 1000
geo.nDetector = np.array((128, 127))
geo.dDetector = np.array((0.8, 0.8)) * 4
geo.sDetector = geo.nDetector * geo.dDetector
geo.nVoxel = np.array((63, 62, 61))
geo.sVoxel = np.array((256, 256, 256))
geo.dVoxel = geo.sVoxel / geo.nVoxel
geo.offOrigin = np.array((0, 0, 0))
geo.offDetector = np.array((0, 0))
geo.accuracy = 0.5
geo.mode = 'cone'
self.angles = np.linspace(0, 2 * np.pi, 100, dtype=np.float32)
self.geo = geo
self.img = np.ones((63, 62, 61), dtype=np.float32)
self.proj = Ax(self.img, self.geo, self.angles)
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 art_data_minimizing(self):
"""
VERBOSE:
for j in range(angleblocks):
angle = np.array([alpha[j]], dtype=np.float32)
proj_err = proj[angle_index[j]] - Ax(res, geo, angle, 'ray-voxel')
weighted_err = W[angle_index[j]] * proj_err
backprj = Atb(weighted_err, geo, angle, 'FDK')
weighted_backprj = 1 / V[angle_index[j]] * backprj
res += weighted_backprj
res[res<0]=0
:return: None
"""
geo = copy.deepcopy(self.geo)
for j in range(len(self.angleblocks)):
if self.blocksize == 1:
angle = np.array([self.angleblocks[j]], dtype=np.float32)
else:
angle = self.angleblocks[j]
if geo.offOrigin.shape[0] == self.angles.shape[0]:
geo.offOrigin = self.geo.offOrigin[j]
if geo.offDetector.shape[0] == self.angles.shape[0]:
geo.offOrin = self.geo.offDetector[j]
if geo.rotDetector.shape[0] == self.angles.shape[0]:
geo.rotDetector = self.geo.rotDetector[j]
if hasattr(geo.DSD, 'shape'):
if geo.DSD.shape[0] == self.angles.shape[0]:
geo.DSD = self.geo.DSD[j]
if hasattr(geo.DSO, 'shape'):
if geo.DSO.shape[0] == self.angles.shape[0]:
geo.DSO = self.geo.DSO[j]
self.res += self.lmbda * 1 / self.third_dim_sum(
self.V[:, :, self.angle_index[j]]) * Atb(
self.W[self.angle_index[j]] *
(self.proj[self.angle_index[j]] -
Ax(self.res, geo, angle, 'interpolated')), geo, angle,
'FDK')
if self.noneg:
self.res = self.res.clip(min=0)
def test_proj_parallel_ray_voxel_shape(self):
setattr(self.geo, 'mode', 'parallel')
self.assertTupleEqual(
Ax(self.img, self.geo, self.angles, 'ray-voxel').shape,
(100, 128, 127))
def gradient_descent(self, geo, angle, iteration):
self.res += self.lmbda * 1. / self.V[iteration] * Atb(
self.W[self.angle_index[iteration]] *
(self.proj[self.angle_index[iteration]] -
Ax(self.res, geo, angle, 'interpolated')), geo, angle, 'FDK')
def reinitialise_cgls(self):
self.__r__ = self.proj - \
Ax(self.res, self.geo, self.angles, 'Siddon', gpuids = self.gpuids)
self.__p__ = Atb(self.__r__, self.geo, self.angles, gpuids=self.gpuids)
p_norm = np.linalg.norm(self.__p__.ravel(), 2)
self.__gamma__ = p_norm * p_norm
from __future__ import print_function
import numpy as np
import tigre.utilities.geometry_default as geometry
import Test_data.data_loader as data_loader
from tigre.utilities.Ax import Ax
from tigre.utilities.plotproj import ppslice
from tigre.utilities.plotproj import plotproj
geo = geometry.TIGREParameters(high_quality=False)
geo.mode = 'cone'
geo.COR = None
source_img = data_loader.load_head_phantom(number_of_voxels=geo.nVoxel)
angles = np.linspace(0, 2 * np.pi, 100, dtype=np.float32)
projsirt = Ax(source_img, geo, angles, 'ray-voxel')
plotproj(projsirt)
#fdk=FDK(projsirt,geo,angles)
# blocksize=input('blocksize:')
niter = 5
# sart=SART(projsirt,geo,angles,niter,init='multigrid',OrderStrategy='angularDistance')
ppslice(projsirt)
def initialise_cgls(self):
self._r = self.proj - Ax(self.res, self.geo, self.angles, 'ray-voxel')
self._p = Atb(self._r, self.geo, self.angles)
p_norm = np.linalg.norm(self._p.ravel(), 2)
self._gamma = p_norm * p_norm
# ---------------GEOMETRY---------------------------
geo = tigre.geometry(mode='parallel',nVoxel = np.array([64,64,64]))
source_img = data_loader.load_head_phantom(number_of_voxels=geo.nVoxel)
# ---------------------ANGLES-------------------------
angles_1 = np.linspace(0, 2 * np.pi, 100, dtype=np.float32)
angles_2 = np.ones((100), dtype=np.float32) * np.array(np.pi / 4, dtype=np.float32)
angles_3 = np.zeros((100), dtype=np.float32)
angles = np.vstack((angles_1, angles_3, angles_3)).T
# --------------------PROJECTION----------------------
proj = Ax(source_img,geo,angles)
# ---------------------RECONSTRUCTION------------------
class lineprofileroveride(IterativeReconAlg):
def __init__(self,proj,geo,angles,niter,**kwargs):
lp = LineProfiler()
lp_wrapper = lp(super(lineprofileroveride,self).__init__)
lp_wrapper(proj,geo,angles,niter,**kwargs)
lp.print_stats()
alg = lineprofileroveride(proj,geo,angles,10,**dict(blocksize = 10))
from __future__ import print_function
import numpy as np
import tigre.utilities.geometry_default as geometry
import Test_data.data_loader as data_loader
from tigre.utilities.Ax import Ax
from tigre.utilities.plotproj import ppslice
from tigre.utilities.plotproj import plotproj
geo = geometry.ConeGeometryDefault(high_quality=False)
geo.mode = 'cone'
geo.COR = None
source_img = data_loader.load_head_phantom(number_of_voxels=geo.nVoxel)
angles = np.linspace(0, 2*np.pi, 100, dtype=np.float32)
projsirt = Ax(source_img, geo, angles, 'Siddon')
plotproj(projsirt)
#fdk=FDK(projsirt,geo,angles)
# blocksize=input('blocksize:')
niter = 5
# sart=SART(projsirt,geo,angles,niter,init='multigrid',OrderStrategy='angularDistance')
ppslice(projsirt)
def reinitialise_cgls(self):
self.__r__ = self.proj - Ax(self.res, self.geo, self.angles, 'ray-voxel')
self.__p__ = Atb(self.__r__, self.geo, self.angles)
p_norm = np.linalg.norm(self.__p__.ravel(), 2)
self.__gamma__ = p_norm * p_norm
def test_proj_parallel_interpolated_shape(self):
setattr(self.geo, 'mode', 'parallel')
self.assertTupleEqual(
Ax(self.img, self.geo, self.angles, 'interpolated').shape,
(100, 128, 127))
