def BP(self, s, out=None):
"""Perform backprojection.
Output must have the right 2D/3D shape. Input may also be flattened.
Output must also be contiguous and float32. This isn't required for the
input, but it is more efficient if it is.
:param : The projection data.
:type s: :class:`numpy.ndarray`
:param out: Array to store result in.
:type out: :class:`numpy.ndarray`
"""
s = self.__checkArray(s, self.sshape)
sid = self.data_mod.link('-sino', self.pg, s)
if out is None:
out = np.zeros(self.vshape, dtype=np.float32)
vid = self.data_mod.link('-vol', self.vg, out)
cfg = creators.astra_dict('BP' + self.appendString)
cfg['ProjectionDataId'] = sid
cfg['ReconstructionDataId'] = vid
cfg['ProjectorId'] = self.proj_id
bp_id = algorithm.create(cfg)
algorithm.run(bp_id)
algorithm.delete(bp_id)
self.data_mod.delete([vid, sid])
return out
def create_sino3d_gpu(data,
proj_geom,
vol_geom,
returnData=True,
gpuIndex=None,
sino_id=None):
"""Create a forward projection of an image (3D).
:param data: Image data or ID.
:type data: :class:`numpy.ndarray` or :class:`int`
:param proj_geom: Projection geometry.
:type proj_geom: :class:`dict`
:param vol_geom: Volume geometry.
:type vol_geom: :class:`dict`
:param returnData: If False, only return the ID of the forward projection.
:type returnData: :class:`bool`
:param gpuIndex: Optional GPU index.
:type gpuIndex: :class:`int`
:returns: :class:`int` or (:class:`int`, :class:`numpy.ndarray`) -- If ``returnData=False``, returns the ID of the forward projection. Otherwise, returns a tuple containing the ID of the forward projection and the forward projection itself, in that order.
"""
if isinstance(data, np.ndarray):
volume_id = data3d.create('-vol', vol_geom, data)
else:
volume_id = data
if sino_id is None:
sino_id = data3d.create('-sino', proj_geom, 0)
algString = 'FP3D_CUDA'
cfg = astra_dict(algString)
if not gpuIndex == None:
cfg['option'] = {'GPUindex': gpuIndex}
cfg['ProjectionDataId'] = sino_id
cfg['VolumeDataId'] = volume_id
alg_id = algorithm.create(cfg)
algorithm.run(alg_id)
algorithm.delete(alg_id)
if isinstance(data, np.ndarray):
data3d.delete(volume_id)
if sino_id is None:
if returnData:
return sino_id, data3d.get(sino_id)
else:
return sino_id
else:
if returnData:
return sino_id, data3d.get_shared(sino_id)
else:
return sino_id
def create_backprojection3d_gpu(data, proj_geom, vol_geom, returnData=True, vol_id=None):
"""Create a backprojection of a sinogram (3D) using CUDA.
:param data: Sinogram data or ID.
:type data: :class:`numpy.ndarray` or :class:`int`
:param proj_geom: Projection geometry.
:type proj_geom: :class:`dict`
:param vol_geom: Volume geometry.
:type vol_geom: :class:`dict`
:param returnData: If False, only return the ID of the backprojection.
:type returnData: :class:`bool`
:param vol_id: ID of the np array linked with astra
:type vol_id: int, default None
:returns: :class:`int` or (:class:`int`, :class:`numpy.ndarray`) -- If ``returnData=False``, returns the ID of the backprojection. Otherwise, returns a tuple containing the ID of the backprojection and the backprojection itself, in that order.
"""
if isinstance(data, np.ndarray):
sino_id = data3d.create('-sino', proj_geom, data)
else:
sino_id = data
if vol_id is None:
vol_id = data3d.create('-vol', vol_geom, 0)
cfg = astra_dict('BP3D_CUDA')
cfg['ProjectionDataId'] = sino_id
cfg['ReconstructionDataId'] = vol_id
alg_id = algorithm.create(cfg)
algorithm.run(alg_id)
algorithm.delete(alg_id)
if isinstance(data, np.ndarray):
data3d.delete(sino_id)
if vol_id is not None:
if returnData:
return vol_id, data3d.get_shared(vol_id)
else:
return vol_id
else:
if returnData:
return vol_id, data3d.get(vol_id)
else:
return vol_id
def reconstruct(self, method, s, iterations=1, extraOptions=None):
"""Reconstruct an object.
:param method: Method to use for reconstruction.
:type method: :class:`string`
:param s: The projection data.
:type s: :class:`numpy.ndarray`
:param iterations: Number of iterations to use.
:type iterations: :class:`int`
:param extraOptions: Extra options to use during reconstruction (i.e. for cfg['option']).
:type extraOptions: :class:`dict`
"""
if extraOptions == {}:
opts = {}
if extraOptions is None:
opts = {}
s = self.__checkArray(s, self.sshape)
sid = self.data_mod.link('-sino', self.pg, s)
v = np.zeros(self.vshape, dtype=np.float32)
vid = self.data_mod.link('-vol', self.vg, v)
cfg = creators.astra_dict(method)
cfg['ProjectionDataId'] = sid
cfg['ReconstructionDataId'] = vid
cfg['ProjectorId'] = self.proj_id
if 'FilterType' in list(extraOptions.keys()):
cfg['FilterType'] = extraOptions['FilterType']
opts = {
key: extraOptions[key]
for key in extraOptions if key != 'FilterType'
}
else:
opts = extraOptions
cfg['option'] = opts
alg_id = algorithm.create(cfg)
algorithm.run(alg_id, iterations)
algorithm.delete(alg_id)
self.data_mod.delete([vid, sid])
return v