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