예제 #1
0
    def backward(ctx, grad_out):
        astra.set_gpu_index([grad_out.device.index],
                            memory=10 * 1024 * 1024 * 1024)

        grad_input = gradProjSize = gradVectors = None

        if ctx.needs_input_grad[0]:
            # permute here to handle opposite data layouts
            bproj_id, bproj_data = astra.create_backprojection3d_gpu(
                grad_out.squeeze(1).permute(2, 0, 1).data.cpu().numpy(),
                ctx.proj_geom, ctx.vol_geom)
            astra.data3d.delete(bproj_id)
            grad_input = Tensor(bproj_data).cuda(non_blocking=True).permute(
                2, 1, 0)

        return grad_input, gradProjSize, gradVectors
예제 #2
0
def import_astra_GPU():
    import astra
    sp = subprocess.Popen(['nvidia-smi', '-q'],
                          stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE)
    out_str = sp.communicate()
    out_list = out_str[0].decode("utf-8").split('\n')
    out_dict = {}

    for item in out_list:
        try:
            key, val = item.split(':')
            key, val = key.strip(), val.strip()
            out_dict[key] = val
        except:
            pass
    num_gpu = int(out_dict['Attached GPUs'])
    astra.set_gpu_index([i for i in range(num_gpu)])
예제 #3
0
"""
import numpy as np
import ddf_fdk as ddf
#ddf.import_astra_GPU()
import nn_fdk as nn
from sacred import Experiment
from sacred.observers import FileStorageObserver
import gc
import pylab
import os
import time
import h5py
import sys
sys.path.append('../nn_fdk/')
import astra
astra.set_gpu_index([0, 1, 2, 3])
import load_and_preprocess_CA as cap
# %%
path = 'python_data/results/'
ex = Experiment()


# %%
@ex.config
def cfg():
    it_i = 1
    it_j = 21
    bp = '/bigstore/lagerwer/data/FleXray/'
    path = f'{bp}Walnuts/Walnut{it_j}/Projections/'
    dset = f'tubeV{2}'
    pd = 'processed_data/'
예제 #4
0
# The ASTRA Toolbox is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#
# -----------------------------------------------------------------------

import astra
import numpy as np

# Set up multi-GPU usage.
# This only works for 3D GPU forward projection and back projection.
astra.set_gpu_index([0, 1])

# Optionally, you can also restrict the amount of GPU memory ASTRA will use.
# The line commented below sets this to 1GB.
#astra.set_gpu_index([0,1], memory=1024*1024*1024)

vol_geom = astra.create_vol_geom(1024, 1024, 1024)

angles = np.linspace(0, np.pi, 1024, False)
proj_geom = astra.create_proj_geom('parallel3d', 1.0, 1.0, 1024, 1024, angles)

# Create a simple hollow cube phantom
cube = np.zeros((1024, 1024, 1024))
cube[128:895, 128:895, 128:895] = 1
cube[256:767, 256:767, 256:767] = 0
예제 #5
0
    def forward(ctx, input, projSize, vectors):  #angles=T(B,3)
        """
        input - GPU tensor
        ctx.vectors - numProj x 12 following astra convention
        ctx.projSize - size in pixels of projections 
        
        returns:
        proj: GPU tensor numProj x 1 x projSize x projSize

        avoid passing back to the cpu
        based on https://github.com/astra-toolbox/astra-toolbox/blob/master/samples/python/s021_pygpu.py
        and https://github.com/astra-toolbox/astra-toolbox/blob/10d87f45bc9311c0408e4cacdec587eff8bc37f8/python/astra/creators.py create_sino3d_gpu
        """

        # pytorch is row major (later dimensions change faster), while astra is col major (opposite)
        # to counteract this, we need to transpose
        # the contiguous is needed to change the memory layout

        astra.set_gpu_index([input.device.index],
                            memory=1 * 1024 * 1024 * 1024)

        input = input.permute(2, 1, 0).contiguous()

        # setup volume
        x, y, z = input.shape

        strideBytes = input.stride(
            -2) * 32 / 8  # 32 bits in a float, 8 bits in a byte
        vol_link = astra.data3d.GPULink(input.data_ptr(), x, y, z, strideBytes)
        vol_geom = astra.create_vol_geom(x, y, z)
        vol_id = astra.data3d.link('-vol', vol_geom, vol_link)

        # setup projection
        proj = torch.empty(projSize,
                           len(vectors),
                           projSize,
                           dtype=torch.float,
                           device='cuda')
        x, y, z = proj.shape
        strideBytes = proj.stride(
            -2) * 32 / 8  # 32 bits in a float, 8 bits in a byte
        proj_link = astra.data3d.GPULink(proj.data_ptr(), x, y, z, strideBytes)
        proj_geom = astra.create_proj_geom('parallel3d_vec', projSize,
                                           projSize, vectors.numpy())
        proj_id = astra.data3d.link('-sino', proj_geom, proj_link)

        cfg = astra.astra_dict('FP3D_CUDA')
        cfg['VolumeDataId'] = vol_id
        cfg['ProjectionDataId'] = proj_id
        alg_id = astra.algorithm.create(cfg)
        astra.algorithm.run(alg_id)

        # again handle the row vs col major problem
        # the output is y_0 x numProj x y_1, which pytorch interprets in the reverse order
        proj = proj.permute(1, 2, 0).unsqueeze(1)

        # store data for back propagation
        ctx.proj_geom = proj_geom
        ctx.vol_geom = vol_geom

        return proj
예제 #6
0
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation, either version 3 of the License, or
#(at your option) any later version.
#
#The Python interface to the ASTRA Toolbox is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#
#You should have received a copy of the GNU General Public License
#along with the Python interface to the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#
#-----------------------------------------------------------------------
import matlab as m
from creators import astra_dict,create_vol_geom, create_proj_geom, create_backprojection, create_sino, create_reconstruction, create_projector,create_sino3d_gpu, create_backprojection3d_gpu
from functions import data_op, add_noise_to_sino,clear
from extrautils import clipCircle
from ASTRAProjector import ASTRAProjector2D
import data2d
import astra
import data3d
import algorithm
import projector
import matrix

import os
try:
    astra.set_gpu_index(int(os.environ['ASTRA_GPU_INDEX']))
except KeyError:
    pass
예제 #7
0
def fwd_gpu_recon(func, i, num_gpus, cors, **kwargs):
    import astra
    astra.set_gpu_index(i % num_gpus)
    second_shared_data[i] = func(shared_data[i], cors[i], **kwargs)
# The ASTRA Toolbox is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#
# -----------------------------------------------------------------------

import astra
import numpy as np

# Set up multi-GPU usage.
# This only works for 3D GPU forward projection and back projection.
astra.set_gpu_index([0,1])

# Optionally, you can also restrict the amount of GPU memory ASTRA will use.
# The line commented below sets this to 1GB.
#astra.set_gpu_index([0,1], memory=1024*1024*1024)

vol_geom = astra.create_vol_geom(1024, 1024, 1024)

angles = np.linspace(0, np.pi, 1024,False)
proj_geom = astra.create_proj_geom('parallel3d', 1.0, 1.0, 1024, 1024, angles)

# Create a simple hollow cube phantom
cube = np.zeros((1024,1024,1024))
cube[128:895,128:895,128:895] = 1
cube[256:767,256:767,256:767] = 0