示例#1
0
def NNFDK_obj(CT_obj, phantom, pix, angles, src_rad, noise, nTrain, nTD, nVal,
              nVD, Exp_bin, bin_param, bpath):
    nn.Create_TrainingValidationData(pix,
                                     phantom,
                                     angles,
                                     src_rad,
                                     noise,
                                     Exp_bin,
                                     bin_param,
                                     nTD + nVD,
                                     base_path=bpath)
    spf_space, Exp_op = ddf.support_functions.ExpOp_builder(
        bin_param, CT_obj.filter_space, interp=Exp_bin)
    # Create the FDK binned operator
    CT_obj.FDK_bin_nn = CT_obj.FDK_op * Exp_op

    # Create the NN-FDK object
    CT_obj.NNFDK = nn.NNFDK_class(CT_obj,
                                  nTrain,
                                  nTD,
                                  nVal,
                                  nVD,
                                  Exp_bin,
                                  Exp_op,
                                  bin_param,
                                  base_path=bpath)
    CT_obj.rec_methods += [CT_obj.NNFDK]
    return CT_obj
示例#2
0
def CT(load_path, dset, sc, ang_freq, Exp_bin, bin_param, nTrain, nTD, nVal,
       nVD, bpath):
    dataset = ddf.load_and_preprocess_real_data(load_path, dset, sc)
    meta = ddf.load_meta(load_path + dset + '/', sc)
    pix_size = meta['pix_size']
    src_rad = meta['s2o']
    det_rad = meta['o2d']

    data_obj = ddf.real_data(dataset,
                             pix_size,
                             src_rad,
                             det_rad,
                             ang_freq,
                             zoom=False)

    CT_obj = ddf.CCB_CT(data_obj)
    CT_obj.init_algo()
    spf_space, Exp_op = ddf.support_functions.ExpOp_builder(
        bin_param, CT_obj.filter_space, interp=Exp_bin)
    # Create the FDK binned operator
    #    CT_obj.FDK_bin_nn = CT_obj.FDK_op * Exp_op

    # Create the NN-FDK object
    CT_obj.NNFDK = nn.NNFDK_class(CT_obj,
                                  nTrain,
                                  nTD,
                                  nVal,
                                  nVD,
                                  Exp_bin,
                                  Exp_op,
                                  bin_param,
                                  dset=dset,
                                  base_path=bpath)
    CT_obj.rec_methods += [CT_obj.NNFDK]
    return CT_obj
示例#3
0
def CT(pix, phantom, angles, src_rad, noise, nTrain, nTD, nVal, nVD,
              Exp_bin, bin_param, f_load_path, g_load_path):
    
    voxels = [pix, pix, pix]
    det_rad = 0
    if g_load_path is not None:
        if f_load_path is not None:
            data_obj = ddf.phantom(voxels, phantom, angles, noise, src_rad,
                                   det_rad, load_data_g=g_load_path,
                                   load_data_f=f_load_path)
        else:
            data_obj = ddf.phantom(voxels, phantom, angles, noise, src_rad,
                               det_rad, load_data_g=g_load_path)
            
    else:
        data_obj = ddf.phantom(voxels, phantom, angles, noise, src_rad,
                                   det_rad)

    CT_obj = ddf.CCB_CT(data_obj)
    CT_obj.init_algo()
    spf_space, Exp_op = ddf.support_functions.ExpOp_builder(bin_param,
                                                         CT_obj.filter_space,
                                                         interp=Exp_bin)
    # Create the FDK binned operator
    CT_obj.FDK_bin_nn = CT_obj.FDK_op * Exp_op

    # Create the NN-FDK object
    CT_obj.NNFDK = nn.NNFDK_class(CT_obj, nTrain, nTD, nVal, nVD, Exp_bin,
                                   Exp_op, bin_param)
    CT_obj.rec_methods += [CT_obj.NNFDK]
    return CT_obj
示例#4
0
def NNFDK_obj(CT_obj, dset, Exp_bin, bin_param, nTrain, nTD, nVal, nVD, bpath):
    spf_space, Exp_op = ddf.support_functions.ExpOp_builder(bin_param,
                                                         CT_obj.filter_space,
                                                         interp=Exp_bin)

    # Create the NN-FDK object
    CT_obj.NNFDK = nn.NNFDK_class(CT_obj, nTrain, nTD, nVal, nVD, Exp_bin,
                                   Exp_op, bin_param, dset=dset,
                                   base_path=bpath)
    CT_obj.rec_methods += [CT_obj.NNFDK]
    return CT_obj
示例#5
0
def CT(path, dset, sc, ang_freq, Exp_bin, bin_param, nTrain, nTD, nVal, nVD,
       vox, bp):
    dataset, vecs = cap.load_and_preprocess(path, dset, ang_freq=ang_freq)
    meta = ddf.load_meta(f'{path}{dset}/', 1)
    pix_size = sc * meta['pix_size']
    src_rad = meta['s2o']
    det_rad = meta['o2d']

    data_obj = ddf.real_data(dataset,
                             pix_size,
                             src_rad,
                             det_rad,
                             ang_freq,
                             vox=vox,
                             vecs=vecs)

    CT_obj = ddf.CCB_CT(data_obj)
    CT_obj.init_algo()
    spf_space, Exp_op = ddf.support_functions.ExpOp_builder(
        bin_param, CT_obj.filter_space, interp=Exp_bin)
    # Create the FDK binned operator
    #    CT_obj.FDK_bin_nn = CT_obj.FDK_op * Exp_op

    # Create the NN-FDK object
    CT_obj.NNFDK = nn.NNFDK_class(CT_obj,
                                  nTrain,
                                  nTD,
                                  nVal,
                                  nVD,
                                  Exp_bin,
                                  Exp_op,
                                  bin_param,
                                  dset=dset,
                                  base_path=bp)
    CT_obj.rec_methods += [CT_obj.NNFDK]
    return CT_obj