Python astra.astra_dict函数代码示例

 def run(self, iterations):
     self.fn = getFilterFile(self.fd, self.pg, iterations, self.rg, self.osz)
     if os.path.exists(self.fn):
         flt = np.load(self.fn)
         self.v[:] = self.customFBP(flt)
         return
     nd = self.nd
     if self.osz:
         nds = self.osz
     else:
         nds = nd
     na = len(self.ang)
     pgc = astra.create_proj_geom('parallel',1.0,nd,self.ang)
     vgc = astra.create_vol_geom((nds,nds))
     pidc = astra.create_projector('strip',pgc,vgc)
     x = np.zeros((nds,nds))
     xs = np.zeros((nds,nds))
     sf = np.zeros((na,nd))
     vid = astra.data2d.create('-vol',vgc)
     sid = astra.data2d.create('-sino',pgc)
     cfg = astra.astra_dict('FP')
     cfg['ProjectorId']=pidc
     cfg['ProjectionDataId']=sid
     cfg['VolumeDataId']=vid
     fpid = astra.algorithm.create(cfg)
     cfg = astra.astra_dict('BP')
     cfg['ProjectorId']=pidc
     cfg['ProjectionDataId']=sid
     cfg['ReconstructionDataId']=vid
     bpid = astra.algorithm.create(cfg)
     vc = astra.data2d.get_shared(vid)
     sc = astra.data2d.get_shared(sid)
     x[nds//2,nds//2]=1
     alp = 1./(na*nds)
     if self.rg:
         if self.rg*alp >=0.1:
             alp = 0.1/self.rg
     astra.log.info('Computing filter...')
     for i in range(iterations):
         if i%10==0: astra.log.info('{:.2f} % done'.format(100*float(i)/iterations))
         xs+=x
         vc[:] = x
         astra.algorithm.run(fpid)
         astra.algorithm.run(bpid)
         if self.rg:
             dx = x[:-1,:] - x[1:,:]
             dy = x[:,:-1] - x[:,1:]
             x[:-1,:] -= self.rg*dx*alp
             x[1:,:] += self.rg*dx*alp
             x[:,:-1] -= self.rg*dy*alp
             x[:,1:] += self.rg*dy*alp
         x -= vc*alp
     vc[:] = xs
     astra.algorithm.run(fpid)
     flt = sc.copy()*alp
     astra.algorithm.delete([fpid,bpid])
     astra.algorithm.delete([vid,sid])
     np.save(self.fn,flt)
     self.v[:] = self.customFBP(flt)
     astra.projector.delete(pidc)

def astrarecon(tilt_data,tilt_angles,iterations=1,geometry='parallel3d',SO_dist=1.0,OD_dist=1.0):
    proj_shape = np.shape(tilt_data)
    recon_shape = (proj_shape[2],proj_shape[2],proj_shape[1])
    
    vol_geom = astra.create_vol_geom(recon_shape)

    angles = np.pi*tilt_angles/180
    
    if geometry == 'parallel3d':
        proj_geom = astra.create_proj_geom(geometry, 1.0, 1.0, proj_shape[1], proj_shape[2], angles)
        cfg = astra.astra_dict('SIRT3D_CUDA')
    elif geometry == 'cone':
        proj_geom = astra.create_proj_geom(geometry, 1.0, 1.0, proj_shape[1], proj_shape[2], angles, SO_dist, OD_dist)
        cfg = astra.astra_dict('FDK_CUDA')
        
    proj_id = astra.data3d.create('-proj3d', proj_geom, np.swapaxes(tilt_data,0,1))
    
    rec_id = astra.data3d.create('-vol', vol_geom)
    
    cfg['ReconstructionDataId'] = rec_id
    cfg['ProjectionDataId'] = proj_id
    
    alg_id = astra.algorithm.create(cfg)
    
    astra.algorithm.run(alg_id, iterations)
    
    rec = astra.data3d.get(rec_id)
    
    astra.algorithm.delete(alg_id)
    astra.data3d.delete(rec_id)
    astra.data3d.delete(proj_id)
    
    return(rec)

 def init(self, volume_data=1, projection_data=1):
     # Create volume geometry
     self.volume_geom = astra.create_vol_geom(self.num_voxel)
 
     # Create projection geometry
     self.projection_geom = astra.create_proj_geom(self.geometry_type,
                                        self.detector_spacing_x, self.detector_spacing_y,
                                        self.det_row_count, self.det_col_count,
                                        self.angles,
                                        self.source_origin, self.origin_detector)
 
     # Allocate and store volume data in ASTRA memory
     self.volume_id = astra.data3d.create('-vol', self.volume_geom, volume_data)
 
     # Allocate and store projection data in ASTRA memeory
     self.projection_id = astra.data3d.create('-sino', self.projection_geom, projection_data)
     
     # Create algorithm object: forward projector
     cfg = astra.astra_dict('FP3D_CUDA')
     cfg['option'] = {'GPUindex': self.gpu_index}
     cfg['ProjectionDataId'] = self.projection_id
     cfg['VolumeDataId'] = self.volume_id
     self.forward_alg_id = astra.algorithm.create(cfg)
     
     # Create algorithm object: backward projector
     cfg = astra.astra_dict('BP3D_CUDA')
     cfg['option'] = {'GPUindex': self.gpu_index}
     cfg['ProjectionDataId'] = self.projection_id
     cfg['ReconstructionDataId'] = self.volume_id
     self.backward_alg_id = astra.algorithm.create(cfg)

    def __init__(self, geometry_type='cone',
                 num_voxel=(100, 100, 100),
                 det_row_count=100, det_col_count=100,
                 angles=np.linspace(0, 2 * np.pi, 180, endpoint=False),
                 det_col_spacing=1.0, det_row_spacing=1.0,
                 source_origin=100.0, origin_detector=10.0,
                 volume_data=1, projection_data=1,
                 gpu_index=0):
        self.geometry_type = geometry_type
        self.num_voxel = num_voxel
        self.detector_spacing_x = det_col_spacing
        self.detector_spacing_y = det_row_spacing
        self.det_row_count = det_row_count
        self.det_col_count = det_col_count
        self.angles = angles
        self.source_origin = source_origin
        self.origin_detector = origin_detector
        self.volume_data = volume_data
        self.projection_data = projection_data
        self.gpu_index = gpu_index

        # Create volume geometry
        self.volume_geom = astra.create_vol_geom(self.num_voxel)

        # Create projection geometry
        self.projection_geom = astra.create_proj_geom(
            self.geometry_type,
            self.detector_spacing_x, self.detector_spacing_y,
            self.det_row_count, self.det_col_count,
            self.angles,
            self.source_origin, self.origin_detector)

        # Allocate and store volume data in ASTRA memory
        self.volume_id = astra.data3d.create(
            '-vol',
            self.volume_geom,
            self.volume_data)

        # Allocate and store projection data in ASTRA memory
        self.projection_id = astra.data3d.create(
            '-sino',
            self.projection_geom,
            self.projection_data)

        # Create algorithm object: forward projector
        cfg = astra.astra_dict('FP3D_CUDA')
        cfg['option'] = {'GPUindex': self.gpu_index}
        cfg['ProjectionDataId'] = self.projection_id
        cfg['VolumeDataId'] = self.volume_id
        self.forward_alg_id = astra.algorithm.create(cfg)

        # Create algorithm object: backward projector
        cfg = astra.astra_dict('BP3D_CUDA')
        # classmethod?
        cfg['option'] = {'GPUindex': self.gpu_index}
        cfg['ProjectionDataId'] = self.projection_id
        cfg['ReconstructionDataId'] = self.volume_id
        self.backward_alg_id = astra.algorithm.create(cfg)

    def _fp_id(self):
        """Create algorithms object of forward projection."""

        geom_type = self.geom.geom_type.lower()
        cfg = None

        if geom_type in self.type2d:
            cfg = astra.astra_dict('FP_CUDA')
        elif geom_type in self.type3d:
            cfg = astra.astra_dict('FP3D_CUDA')
        cfg['option'] = {'GPUindex': self.gpu_index}
        cfg['ProjectionDataId'] = self.proj_id
        cfg['VolumeDataId'] = self.vol_id

        return astra.algorithm.create(cfg)

    def backward(self, proj_vector=None):
        """Backprojection."""

        # Store projection data in ASTRA memory
        if proj_vector is None:
            astra.data3d.store(self.proj_id,
                               self.proj.data.reshape(
                                   self.geom.det_row_count,
                                   self.geom.angles.size,
                                   self.geom.det_col_count))
        else:
            astra.data3d.store(self.proj_id,
                               proj_vector.data.reshape(
                                   self.geom.det_row_count,
                                   self.geom.angles.size,
                                   self.geom.det_col_count))

        # Create algorithm object
        cfg = astra.astra_dict('BP3D_CUDA')
        cfg['option'] = {'GPUindex': self.gpu_index}
        cfg['ProjectionDataId'] = self.proj_id
        cfg['ReconstructionDataId'] = self.volume_id
        self.bp_id = astra.algorithm.create(cfg)

        # Run algorithms
        astra.algorithm.run(self.bp_id)

        # Retrieve projection from ASTRA memory
        self.vol.data[:] = np.ravel(astra.data3d.get(self.volume_id))

 def cfg_setup(self):
     cfg = astra.astra_dict(self.name)
     cfg['ReconstructionDataId'] = self.rec_id
     cfg['ProjectionDataId'] = self.sino_id
     if 'CUDA' in self.name:
         cfg['option'] = {'GPUindex': self.parameters['GPU_index']}
     return cfg

def astra_rec_cuda(tomo, center, recon, theta, vol_geom, niter, proj_type, gpu_index, opts):
    # Lazy import ASTRA
    import astra as astra_mod
    nslices, nang, ndet = tomo.shape
    cfg = astra_mod.astra_dict(opts['method'])
    if 'extra_options' in opts:
        # NOTE: we are modifying 'extra_options' and so need to make a copy
        cfg['option'] = copy.deepcopy(opts['extra_options'])
    else:
        cfg['option'] = {}
    if gpu_index is not None:
        cfg['option']['GPUindex'] = gpu_index
    oc = None
    const_theta = np.ones(nang)
    proj_geom = astra_mod.create_proj_geom(
        'parallel', 1.0, ndet, theta.astype(np.float64))
    for i in range(nslices):
        if center[i] != oc:
            oc = center[i]
            proj_geom['option'] = {
                'ExtraDetectorOffset':
                (center[i] - ndet / 2.) * const_theta}
        pid = astra_mod.create_projector(proj_type, proj_geom, vol_geom)
        cfg['ProjectorId'] = pid
        sid = astra_mod.data2d.link('-sino', proj_geom, tomo[i])
        cfg['ProjectionDataId'] = sid
        vid = astra_mod.data2d.link('-vol', vol_geom, recon[i])
        cfg['ReconstructionDataId'] = vid
        alg_id = astra_mod.algorithm.create(cfg)
        astra_mod.algorithm.run(alg_id, niter)
        astra_mod.algorithm.delete(alg_id)
        astra_mod.data2d.delete(vid)
        astra_mod.data2d.delete(sid)
        astra_mod.projector.delete(pid)

def astra_rec_cpu(tomo, center, recon, theta, vol_geom, niter, proj_type, opts):
    # Lazy import ASTRA
    import astra as astra_mod
    nslices, nang, ndet = tomo.shape
    cfg = astra_mod.astra_dict(opts['method'])
    if 'extra_options' in opts:
        cfg['option'] = opts['extra_options']
    proj_geom = astra_mod.create_proj_geom('parallel', 1.0, ndet, theta.astype(np.float64))
    pid = astra_mod.create_projector(proj_type, proj_geom, vol_geom)
    sino = np.zeros((nang, ndet), dtype=np.float32)
    sid = astra_mod.data2d.link('-sino', proj_geom, sino)
    cfg['ProjectorId'] = pid
    cfg['ProjectionDataId'] = sid
    for i in range(nslices):
        shft = int(np.round(ndet / 2. - center[i]))
        if not shft == 0:
            sino[:] = np.roll(tomo[i], shft)
            l = shft
            r = ndet + shft
            if l < 0:
                l = 0
            if r > ndet:
                r = ndet
            sino[:, :l] = 0
            sino[:,  r:] = 0
        else:
            sino[:] = tomo[i]
        vid = astra_mod.data2d.link('-vol', vol_geom, recon[i])
        cfg['ReconstructionDataId'] = vid
        alg_id = astra_mod.algorithm.create(cfg)
        astra_mod.algorithm.run(alg_id, niter)
        astra_mod.algorithm.delete(alg_id)
        astra_mod.data2d.delete(vid)
    astra_mod.data2d.delete(sid)
    astra_mod.projector.delete(pid)

    def reconstruct(self, sinogram, centre_of_rotation, angles, shape, center):

        ctr = centre_of_rotation
        width = sinogram.shape[1]
        pad = 50

        sino = np.nan_to_num(sinogram)

        # pad the array so that the centre of rotation is in the middle
        alen = ctr
        blen = width - ctr
        mid = width / 2.0

        if (ctr > mid):
            plow = pad
            phigh = (alen - blen) + pad
        else:
            plow = (blen - alen) + pad
            phigh = pad

        logdata = np.log(sino+1)
        sinogram = np.pad(logdata, ((0, 0), (int(plow), int(phigh))),
                          mode='reflect')

        width = sinogram.shape[1]

        vol_geom = astra.create_vol_geom(shape[0], shape[1])
        proj_geom = astra.create_proj_geom('parallel', 1.0, width,
                                           np.deg2rad(angles))

        sinogram_id = astra.data2d.create("-sino", proj_geom, sinogram)

        # Create a data object for the reconstruction
        rec_id = astra.data2d.create('-vol', vol_geom)

        proj_id = astra.create_projector('strip', proj_geom, vol_geom)

        cfg = astra.astra_dict(self.parameters['reconstruction_type'])
        cfg['ReconstructionDataId'] = rec_id
        cfg['ProjectionDataId'] = sinogram_id
        cfg['ProjectorId'] = proj_id

        # Create the algorithm object from the configuration structure
        alg_id = astra.algorithm.create(cfg)
        # Run 20 iterations of the algorithm
        itterations = int(self.parameters['number_of_iterations'])
        # This will have a runtime in the order of 10 seconds.
        astra.algorithm.run(alg_id, itterations)
        # Get the result
        rec = astra.data2d.get(rec_id)

        # Clean up.
        astra.algorithm.delete(alg_id)
        astra.data2d.delete(rec_id)
        astra.data2d.delete(sinogram_id)

        return rec

    def forward(self, vol_space_vector):
        """Forward projection."""

        if self.geom.vol_ndim == 2:

            # Store volume data in ASTRA memory
            astra.data2d.store(self.volume_id,
                               vol_space_vector.data.reshape(
                                   self.geom.vol_shape))

            # Create algorithm object
            cfg = astra.astra_dict('FP_CUDA')
            cfg['option'] = {'GPUindex': self.gpu_index}
            cfg['ProjectionDataId'] = self.proj_id
            cfg['VolumeDataId'] = self.volume_id
            self.fp_id = astra.algorithm.create(cfg)

            # Run algorithm
            astra.algorithm.run(self.fp_id)

            # Retrieve projection data from ASTRA memory
            return self.proj_space.element(self.scal_fac * np.ravel(
                astra.data2d.get(self.proj_id)))

        elif self.geom.vol_ndim == 3:

            # Store volume data in ASTRA memory
            astra.data3d.store(self.volume_id,
                               vol_space_vector.data.reshape(
                                   self.geom.vol_shape))

            # Create algorithm object
            cfg = astra.astra_dict('FP3D_CUDA')
            cfg['option'] = {'GPUindex': self.gpu_index}
            cfg['ProjectionDataId'] = self.proj_id
            cfg['VolumeDataId'] = self.volume_id
            self.fp_id = astra.algorithm.create(cfg)

            # Run algorithm
            astra.algorithm.run(self.fp_id)

            # Retrieve projection data from ASTRA memory
            return self.proj_space.element(self.scal_fac * np.ravel(
                astra.data3d.get(self.proj_id)))

    def _fbp_id(self):
        """Create algorithms object of back-projection."""

        geom_type = self.geom.geom_type.lower()

        if geom_type == 'parallel3d':
            return None

        cfg = None

        if geom_type in self.type2d:
            cfg = astra.astra_dict('FBP_CUDA')
        elif geom_type == 'cone':
            cfg = astra.astra_dict('FDK_CUDA')

        cfg['option'] = {'GPUindex': self.gpu_index}
        cfg['ProjectionDataId'] = self.proj_id
        cfg['ReconstructionDataId'] = self.vol_id

        return astra.algorithm.create(cfg)

 def set_config(self, rec_id, sino_id, proj_geom, vol_geom):
     cfg = astra.astra_dict(self.alg)
     cfg['ReconstructionDataId'] = rec_id
     cfg['ProjectionDataId'] = sino_id
     if 'FBP' in self.alg:
         fbp_filter = self.parameters['FBP_filter'] if 'FBP_filter' in \
             self.parameters.keys() else 'none'
         cfg['FilterType'] = fbp_filter
     if 'projector' in self.parameters.keys():
         proj_id = astra.create_projector(
             self.parameters['projector'], proj_geom, vol_geom)
         cfg['ProjectorId'] = proj_id
     cfg = self.set_options(cfg)
     return cfg

 def run_algorithm(self, alg, n_it, data):
     rec_id = astra.data2d.create('-vol', self.vol_geom)
     sino_id = astra.data2d.create('-sino', self.proj_geom, data)
     cfg = astra.astra_dict(alg)
     cfg['ReconstructionDataId'] = rec_id
     cfg['ProjectionDataId'] = sino_id
     alg_id = astra.algorithm.create(cfg)
     print("Running %s" %alg)
     astra.algorithm.run(alg_id, n_it)
     rec = astra.data2d.get(rec_id)
     astra.algorithm.delete(alg_id)
     astra.data2d.delete(rec_id)
     astra.data2d.delete(sino_id)
     return rec

def cg_alg(proj_id, sid, vid):
    # CG algorithm
    cfg = astra.astra_dict('CG')
    cfg['ProjectorId'] = proj_id
    cfg['ProjectionDataId'] = sid
    cfg['ReconstructionDataId'] = vid
    cfg['option'] = {}
    alg_id = astra.algorithm.create(cfg)
    astra.algorithm.run(alg_id, 100)
    rec = astra.data2d.get(vid)
    rec = np.flipud(rec)
    plt.imsave('rec_cg.png', rec, cmap = plt.cm.gray)
    save_one_image(rec, 'reconstruct', 'rec_cg_.png')

    astra.algorithm.delete(alg_id)
    return rec