complex float* compute_psf(unsigned int N, const long img2_dims[N], const long trj_dims[N], const complex float* traj, const complex float* weights)
{
long ksp_dims1[N];
md_select_dims(N, ~MD_BIT(0), ksp_dims1, trj_dims);
struct linop_s* op2 = nufft_create(N, ksp_dims1, img2_dims, trj_dims, traj, NULL,
nufft_conf_defaults, false);
complex float* ones = md_alloc(N, ksp_dims1, CFL_SIZE);
md_zfill(N, ksp_dims1, ones, 1.);
if (NULL != weights) {
md_zmul(N, ksp_dims1, ones, ones, weights);
md_zmulc(N, ksp_dims1, ones, ones, weights);
}
complex float* psft = md_alloc(N, img2_dims, CFL_SIZE);
linop_adjoint_unchecked(op2, psft, ones);
md_free(ones);
linop_free(op2);
return psft;
}
static
const struct linop_s* sense_nc_init(const long max_dims[DIMS], const long map_dims[DIMS], const complex float* maps, const long ksp_dims[DIMS], const long traj_dims[DIMS], const complex float* traj, struct nufft_conf_s conf, _Bool use_gpu)
{
long coilim_dims[DIMS];
long img_dims[DIMS];
md_select_dims(DIMS, ~MAPS_FLAG, coilim_dims, max_dims);
md_select_dims(DIMS, ~COIL_FLAG, img_dims, max_dims);
const struct linop_s* fft_op = nufft_create(DIMS, ksp_dims, coilim_dims, traj_dims, traj, NULL, conf, use_gpu);
const struct linop_s* maps_op = maps2_create(coilim_dims, map_dims, img_dims, maps, use_gpu);
const struct linop_s* lop = linop_chain(maps_op, fft_op);
linop_free(maps_op);
linop_free(fft_op);
return lop;
}
static
const struct linop_s* sense_nc_init(const long max_dims[DIMS], const long map_dims[DIMS], const complex float* maps, const long ksp_dims[DIMS], const long traj_dims[DIMS], const complex float* traj, struct nufft_conf_s conf, struct operator_s** precond_op)
{
long coilim_dims[DIMS];
long img_dims[DIMS];
md_select_dims(DIMS, ~MAPS_FLAG, coilim_dims, max_dims);
md_select_dims(DIMS, ~COIL_FLAG, img_dims, max_dims);
const struct linop_s* fft_op = nufft_create(DIMS, ksp_dims, coilim_dims, traj_dims, traj, NULL, conf);
const struct linop_s* maps_op = maps2_create(coilim_dims, map_dims, img_dims, maps);
//precond_op[0] = (struct operator_s*) nufft_precond_create( fft_op );
precond_op[0] = NULL;
const struct linop_s* lop = linop_chain(maps_op, fft_op);
linop_free(maps_op);
linop_free(fft_op);
return lop;
}
struct iter_conjgrad_conf cgconf = iter_conjgrad_defaults;
cgconf.maxiter = maxiter;
cgconf.l2lambda = 0.;
cgconf.tol = 0;
const struct linop_s* nufft_op;
// Get nufft_op
if (two)
#ifdef BERKELEY_SVN
nufft_op = nufft2_create(ksp_dims, coilim_dims, traj, pat, toeplitz, precond, &cgconf, use_gpu);
#else
assert(!two);
#endif
else
nufft_op = nufft_create(ksp_dims, coilim_dims, traj, pat, toeplitz, precond, stoch, &cgconf, use_gpu);
if (inverse) {
linop_pseudo_inv(nufft_op, lambda, DIMS, coilim_dims, img, DIMS, ksp_dims, ksp);
} else {
linop_adjoint(nufft_op, DIMS, coilim_dims, img, DIMS, ksp_dims, ksp);
}
if (calib) {
fftc(DIMS, coilim_dims, FFT_FLAGS, img, img);
md_resize_center(DIMS, out_dims, out, coilim_dims, img, CFL_SIZE);
md_free(img);
int main_nufft(int argc, char* argv[])
{
bool adjoint = false;
bool inverse = false;
bool use_gpu = false;
bool precond = false;
bool dft = false;
struct nufft_conf_s conf = nufft_conf_defaults;
struct iter_conjgrad_conf cgconf = iter_conjgrad_defaults;
long coilim_vec[3] = { 0 };
float lambda = 0.;
const struct opt_s opts[] = {
OPT_SET('a', &adjoint, "adjoint"),
OPT_SET('i', &inverse, "inverse"),
OPT_VEC3('d', &coilim_vec, "x:y:z", "dimensions"),
OPT_VEC3('D', &coilim_vec, "", "()"),
OPT_SET('t', &conf.toeplitz, "Toeplitz embedding for inverse NUFFT"),
OPT_SET('c', &precond, "Preconditioning for inverse NUFFT"),
OPT_FLOAT('l', &lambda, "lambda", "l2 regularization"),
OPT_UINT('m', &cgconf.maxiter, "", "()"),
OPT_SET('s', &dft, "DFT"),
};
cmdline(&argc, argv, 3, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
long coilim_dims[DIMS] = { 0 };
md_copy_dims(3, coilim_dims, coilim_vec);
// Read trajectory
long traj_dims[DIMS];
complex float* traj = load_cfl(argv[1], DIMS, traj_dims);
assert(3 == traj_dims[0]);
num_init();
if (inverse || adjoint) {
long ksp_dims[DIMS];
const complex float* ksp = load_cfl(argv[2], DIMS, ksp_dims);
assert(1 == ksp_dims[0]);
assert(md_check_compat(DIMS, ~(PHS1_FLAG|PHS2_FLAG), ksp_dims, traj_dims));
md_copy_dims(DIMS - 3, coilim_dims + 3, ksp_dims + 3);
if (0 == md_calc_size(DIMS, coilim_dims)) {
estimate_im_dims(DIMS, coilim_dims, traj_dims, traj);
debug_printf(DP_INFO, "Est. image size: %ld %ld %ld\n", coilim_dims[0], coilim_dims[1], coilim_dims[2]);
}
complex float* img = create_cfl(argv[3], DIMS, coilim_dims);
md_clear(DIMS, coilim_dims, img, CFL_SIZE);
const struct linop_s* nufft_op;
if (!dft)
nufft_op = nufft_create(DIMS, ksp_dims, coilim_dims, traj_dims, traj, NULL, conf, use_gpu);
else
nufft_op = nudft_create(DIMS, FFT_FLAGS, ksp_dims, coilim_dims, traj_dims, traj);
if (inverse) {
const struct operator_s* precond_op = NULL;
if (conf.toeplitz && precond)
precond_op = nufft_precond_create(nufft_op);
lsqr(DIMS, &(struct lsqr_conf){ lambda }, iter_conjgrad, CAST_UP(&cgconf),
nufft_op, NULL, coilim_dims, img, ksp_dims, ksp, precond_op);
if (conf.toeplitz && precond)
operator_free(precond_op);
} else {
int main_nufft(int argc, char* argv[])
{
int c;
bool adjoint = false;
bool inverse = false;
bool use_gpu = false;
bool sizeinit = false;
struct nufft_conf_s conf = nufft_conf_defaults;
struct iter_conjgrad_conf cgconf = iter_conjgrad_defaults;
long coilim_dims[DIMS];
md_singleton_dims(DIMS, coilim_dims);
float lambda = 0.;
while (-1 != (c = getopt(argc, argv, "d:m:l:aiht"))) {
switch (c) {
case 'i':
inverse = true;
break;
case 'a':
adjoint = true;
break;
case 'd':
sscanf(optarg, "%ld:%ld:%ld", &coilim_dims[0], &coilim_dims[1], &coilim_dims[2]);
sizeinit = true;
break;
case 'm':
cgconf.maxiter = atoi(optarg);
break;
case 'l':
lambda = atof(optarg);
break;
case 't':
conf.toeplitz = true;
break;
case 'h':
usage(argv[0], stdout);
help();
exit(0);
default:
usage(argv[0], stderr);
exit(1);
}
}
if (argc - optind != 3) {
usage(argv[0], stderr);
exit(1);
}
// Read trajectory
long traj_dims[DIMS];
complex float* traj = load_cfl(argv[optind + 0], DIMS, traj_dims);
assert(3 == traj_dims[0]);
num_init();
if (inverse || adjoint) {
long ksp_dims[DIMS];
const complex float* ksp = load_cfl(argv[optind + 1], DIMS, ksp_dims);
assert(1 == ksp_dims[0]);
assert(md_check_compat(DIMS, ~(PHS1_FLAG|PHS2_FLAG), ksp_dims, traj_dims));
md_copy_dims(DIMS - 3, coilim_dims + 3, ksp_dims + 3);
if (!sizeinit) {
estimate_im_dims(DIMS, coilim_dims, traj_dims, traj);
debug_printf(DP_INFO, "Est. image size: %ld %ld %ld\n", coilim_dims[0], coilim_dims[1], coilim_dims[2]);
}
complex float* img = create_cfl(argv[optind + 2], DIMS, coilim_dims);
md_clear(DIMS, coilim_dims, img, CFL_SIZE);
const struct linop_s* nufft_op = nufft_create(DIMS, ksp_dims, coilim_dims, traj_dims, traj, NULL, conf, use_gpu);
if (inverse) {
lsqr(DIMS, &(struct lsqr_conf){ lambda }, iter_conjgrad, &cgconf,
nufft_op, NULL, coilim_dims, img, ksp_dims, ksp);
} else {
