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",
gpuids=self.gpuids)
W[W <= min(self.geo.dVoxel / 2)] = np.inf
W = 1.0 / W
setattr(self, "W", W)
def run_main_iter(self):
self.res[self.res < 0.0] = 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",
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
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, '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 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 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)
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 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. / 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 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_ray_voxel_shape(self):
self.assertTupleEqual(
Ax(self.img, self.geo, self.angles, 'ray-voxel').shape,
(100, 128, 127))
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 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')
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 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 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))
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))
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
def test_proj_interpolated_shape(self):
img = self.img
self.assertTupleEqual(
Ax(img, self.geo, self.angles, 'interpolated').shape,
(100, 128, 127))