int main_bpsense(int argc, char* argv[])
{
// -----------------------------------------------------------
// set up conf and option parser
struct bpsense_conf conf = bpsense_defaults;
struct iter_admm_conf iconf = iter_admm_defaults;
conf.iconf = &iconf;
conf.iconf->rho = 10; // more sensibile default
bool usegpu = false;
const char* psf = NULL;
const char* image_truth_fname = NULL;
bool im_truth = false;
bool use_tvnorm = false;
double start_time = timestamp();
const struct opt_s opts[] = {
OPT_FLOAT('e', &conf.eps, "eps", "data consistency error"),
OPT_FLOAT('r', &conf.lambda, "lambda", "l2 regularization parameter"),
OPT_FLOAT('u', &conf.iconf->rho, "rho", "ADMM penalty parameter"),
OPT_SET('c', &conf.rvc, "real-value constraint"),
OPT_SET('t', &use_tvnorm, "use TV norm"),
OPT_STRING('T', &image_truth_fname, "file", "compare to truth image"),
OPT_UINT('i', &conf.iconf->maxiter, "iter", "max. iterations"),
OPT_SET('g', &usegpu, "(use gpu)"),
OPT_STRING('p', &psf, "file", "point-spread function"),
};
cmdline(&argc, argv, 3, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
if (NULL != image_truth_fname)
im_truth = true;
// -----------------------------------------------------------
// load data and print some info about the recon
int N = DIMS;
long dims[N];
long dims1[N];
long img_dims[N];
long ksp_dims[N];
complex float* kspace_data = load_cfl(argv[1], N, ksp_dims);
complex float* sens_maps = load_cfl(argv[2], N, dims);
for (int i = 0; i < 4; i++) // sizes2[4] may be > 1
if (ksp_dims[i] != dims[i])
error("Dimensions of kspace and sensitivities do not match!\n");
assert(1 == ksp_dims[MAPS_DIM]);
(usegpu ? num_init_gpu : num_init)();
if (dims[MAPS_DIM] > 1)
debug_printf(DP_INFO, "%ld maps.\nESPIRiT reconstruction.\n", dims[4]);
if (conf.lambda > 0.)
debug_printf(DP_INFO, "l2 regularization: %f\n", conf.lambda);
if (use_tvnorm)
debug_printf(DP_INFO, "use Total Variation\n");
else
debug_printf(DP_INFO, "use Wavelets\n");
if (im_truth)
debug_printf(DP_INFO, "Compare to truth\n");
md_select_dims(N, ~(COIL_FLAG | MAPS_FLAG), dims1, dims);
md_select_dims(N, ~COIL_FLAG, img_dims, dims);
// -----------------------------------------------------------
// initialize sampling pattern
complex float* pattern = NULL;
long pat_dims[N];
if (NULL != psf) {
pattern = load_cfl(psf, N, pat_dims);
// FIXME: check compatibility
} else {
pattern = md_alloc(N, dims1, CFL_SIZE);
estimate_pattern(N, ksp_dims, COIL_DIM, pattern, kspace_data);
}
// -----------------------------------------------------------
// print some statistics
size_t T = md_calc_size(N, dims1);
long samples = (long)pow(md_znorm(N, dims1, pattern), 2.);
debug_printf(DP_INFO, "Size: %ld Samples: %ld Acc: %.2f\n", T, samples, (float)T/(float)samples);
// -----------------------------------------------------------
// fftmod to un-center data
fftmod(N, ksp_dims, FFT_FLAGS, kspace_data, kspace_data);
fftmod(N, dims, FFT_FLAGS, sens_maps, sens_maps);
// -----------------------------------------------------------
// apply scaling
float scaling = estimate_scaling(ksp_dims, NULL, kspace_data);
debug_printf(DP_INFO, "Scaling: %f\n", scaling);
if (scaling != 0.)
md_zsmul(N, ksp_dims, kspace_data, kspace_data, 1. / scaling);
// -----------------------------------------------------------
// create l1 prox operator and transform
long minsize[DIMS] = { [0 ... DIMS - 1] = 1 };
minsize[0] = MIN(img_dims[0], 16);
minsize[1] = MIN(img_dims[1], 16);
minsize[2] = MIN(img_dims[2], 16);
const struct linop_s* l1op = NULL;
const struct operator_p_s* l1prox = NULL;
if (use_tvnorm) {
l1op = grad_init(DIMS, img_dims, FFT_FLAGS);
l1prox = prox_thresh_create(DIMS + 1, linop_codomain(l1op)->dims, 1., 0u, usegpu);
conf.l1op_obj = l1op;
} else {
bool randshift = true;
l1op = linop_identity_create(DIMS, img_dims);
conf.l1op_obj = wavelet_create(DIMS, img_dims, FFT_FLAGS, minsize, false, usegpu);
l1prox = prox_wavethresh_create(DIMS, img_dims, FFT_FLAGS, minsize, 1., randshift, usegpu);
}
// -----------------------------------------------------------
// create image and load truth image
complex float* image = create_cfl(argv[3], N, img_dims);
md_clear(N, img_dims, image, CFL_SIZE);
long img_truth_dims[DIMS];
complex float* image_truth = NULL;
if (im_truth)
image_truth = load_cfl(image_truth_fname, DIMS, img_truth_dims);
// -----------------------------------------------------------
// call recon
if (usegpu)
#ifdef USE_CUDA
bpsense_recon_gpu(&conf, dims, image, sens_maps, dims1, pattern, l1op, l1prox, ksp_dims, kspace_data, image_truth);
#else
assert(0);
#endif
else
int main_pocsense(int argc, char* argv[])
{
float alpha = 0.;
int maxiter = 50;
bool l1wav = false;
float lambda = -1.;
bool use_gpu = false;
bool use_admm = false;
float admm_rho = -1.;
int l1type = 2;
const struct opt_s opts[] = {
{ 'i', true, opt_int, &maxiter, NULL },
{ 'r', true, opt_float, &alpha, " alpha\tregularization parameter" },
{ 'l', true, opt_int, &l1type, "1/-l2\t\ttoggle l1-wavelet or l2 regularization" },
{ 'g', false, opt_set, &use_gpu, NULL },
{ 'o', true, opt_float, &lambda, NULL },
{ 'm', true, opt_float, &admm_rho, NULL },
};
cmdline(&argc, argv, 3, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
if (1 == l1type)
l1wav = true;
else
if (2 == l1type)
l1wav = false;
else
error("Unknown regularization type.");
unsigned int N = DIMS;
long dims[N];
long ksp_dims[N];
complex float* kspace_data = load_cfl(argv[1], N, ksp_dims);
complex float* sens_maps = load_cfl(argv[2], N, dims);
for (int i = 0; i < 4; i++) // sizes2[4] may be > 1
if (ksp_dims[i] != dims[i])
error("Dimensions of kspace and sensitivities do not match!\n");
assert(1 == ksp_dims[MAPS_DIM]);
num_init();
long dims1[N];
md_select_dims(N, ~(COIL_FLAG|MAPS_FLAG), dims1, dims);
// -----------------------------------------------------------
// memory allocation
complex float* result = create_cfl(argv[3], N, ksp_dims);
complex float* pattern = md_alloc(N, dims1, CFL_SIZE);
// -----------------------------------------------------------
// pre-process data
float scaling = estimate_scaling(ksp_dims, NULL, kspace_data);
md_zsmul(N, ksp_dims, kspace_data, kspace_data, 1. / scaling);
estimate_pattern(N, ksp_dims, COIL_DIM, pattern, kspace_data);
// -----------------------------------------------------------
// l1-norm threshold operator
const struct operator_p_s* thresh_op = NULL;
const struct linop_s* wave_op = NULL;
if (l1wav) {
long minsize[DIMS] = { [0 ... DIMS - 1] = 1 };
minsize[0] = MIN(ksp_dims[0], 16);
minsize[1] = MIN(ksp_dims[1], 16);
minsize[2] = MIN(ksp_dims[2], 16);
wave_op = wavelet_create(DIMS, ksp_dims, FFT_FLAGS, minsize, true, use_gpu);
thresh_op = prox_unithresh_create(DIMS, wave_op, alpha, COIL_FLAG, use_gpu);
}
#if 0
else {
int main_pocsense(int argc, char* argv[])
{
int c;
float alpha = 0.;
int maxiter = 50;
bool l1wav = false;
float lambda = -1.;
bool use_gpu = false;
bool use_admm = false;
float admm_rho = 0.1;
while (-1 != (c = getopt(argc, argv, "m:ghi:r:o:l:"))) {
switch (c) {
case 'i':
maxiter = atoi(optarg);
break;
case 'r':
alpha = atof(optarg);
break;
case 'l':
if (1 == atoi(optarg))
l1wav = true;
else
if (2 == atoi(optarg))
l1wav = false;
else {
usage(argv[0], stderr);
exit(1);
}
break;
case 'g':
use_gpu = true;
break;
case 'o':
lambda = atof(optarg);
break;
case 'm':
use_admm = true;
admm_rho = atof(optarg);
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);
}
unsigned int N = DIMS;
long dims[N];
long ksp_dims[N];
complex float* kspace_data = load_cfl(argv[optind + 0], N, ksp_dims);
complex float* sens_maps = load_cfl(argv[optind + 1], N, dims);
for (int i = 0; i < 4; i++) { // sizes2[4] may be > 1
if (ksp_dims[i] != dims[i]) {
fprintf(stderr, "Dimensions of kspace and sensitivities do not match!\n");
exit(1);
}
}
assert(1 == ksp_dims[MAPS_DIM]);
num_init();
long dims1[N];
md_select_dims(N, ~(COIL_FLAG|MAPS_FLAG), dims1, dims);
// -----------------------------------------------------------
// memory allocation
complex float* result = create_cfl(argv[optind + 2], N, ksp_dims);
complex float* pattern = md_alloc(N, dims1, CFL_SIZE);
// -----------------------------------------------------------
// pre-process data
float scaling = estimate_scaling(ksp_dims, NULL, kspace_data);
md_zsmul(N, ksp_dims, kspace_data, kspace_data, 1. / scaling);
estimate_pattern(N, ksp_dims, COIL_DIM, pattern, kspace_data);
// -----------------------------------------------------------
// l1-norm threshold operator
const struct operator_p_s* thresh_op = NULL;
const struct linop_s* wave_op = NULL;
if (l1wav) {
long minsize[DIMS] = { [0 ... DIMS - 1] = 1 };
minsize[0] = MIN(ksp_dims[0], 16);
minsize[1] = MIN(ksp_dims[1], 16);
minsize[2] = MIN(ksp_dims[2], 16);
wave_op = wavelet_create(DIMS, ksp_dims, FFT_FLAGS, minsize, true, use_gpu);
thresh_op = prox_unithresh_create(DIMS, wave_op, alpha, COIL_FLAG, use_gpu);
}
#if 0
else {
int main_nlinv(int argc, char* argv[])
{
int iter = 8;
float l1 = -1.;
bool waterfat = false;
bool rvc = false;
bool normalize = true;
float restrict_fov = -1.;
float csh[3] = { 0., 0., 0. };
bool usegpu = false;
const char* psf = NULL;
const struct opt_s opts[] = {
{ 'l', true, opt_float, &l1, NULL },
{ 'i', true, opt_int, &iter, NULL },
{ 'c', false, opt_set, &rvc, NULL },
{ 'N', false, opt_clear, &normalize, NULL },
{ 'f', true, opt_float, &restrict_fov, NULL },
{ 'p', true, opt_string, &psf, NULL },
{ 'g', false, opt_set, &usegpu, NULL },
};
cmdline(&argc, argv, 2, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
num_init();
assert(iter > 0);
long ksp_dims[DIMS];
complex float* kspace_data = load_cfl(argv[1], DIMS, ksp_dims);
long dims[DIMS];
md_copy_dims(DIMS, dims, ksp_dims);
if (waterfat)
dims[CSHIFT_DIM] = 2;
long img_dims[DIMS];
md_select_dims(DIMS, FFT_FLAGS|CSHIFT_FLAG, img_dims, dims);
long img_strs[DIMS];
md_calc_strides(DIMS, img_strs, img_dims, CFL_SIZE);
complex float* image = create_cfl(argv[2], DIMS, img_dims);
long msk_dims[DIMS];
md_select_dims(DIMS, FFT_FLAGS, msk_dims, dims);
long msk_strs[DIMS];
md_calc_strides(DIMS, msk_strs, msk_dims, CFL_SIZE);
complex float* mask;
complex float* norm = md_alloc(DIMS, msk_dims, CFL_SIZE);
complex float* sens;
if (4 == argc) {
sens = create_cfl(argv[3], DIMS, ksp_dims);
} else {
sens = md_alloc(DIMS, ksp_dims, CFL_SIZE);
}
complex float* pattern = NULL;
long pat_dims[DIMS];
if (NULL != psf) {
pattern = load_cfl(psf, DIMS, pat_dims);
// FIXME: check compatibility
} else {
pattern = md_alloc(DIMS, img_dims, CFL_SIZE);
estimate_pattern(DIMS, ksp_dims, COIL_DIM, pattern, kspace_data);
}
if (waterfat) {
size_t size = md_calc_size(DIMS, msk_dims);
md_copy(DIMS, msk_dims, pattern + size, pattern, CFL_SIZE);
long shift_dims[DIMS];
md_select_dims(DIMS, FFT_FLAGS, shift_dims, msk_dims);
long shift_strs[DIMS];
md_calc_strides(DIMS, shift_strs, shift_dims, CFL_SIZE);
complex float* shift = md_alloc(DIMS, shift_dims, CFL_SIZE);
unsigned int X = shift_dims[READ_DIM];
unsigned int Y = shift_dims[PHS1_DIM];
unsigned int Z = shift_dims[PHS2_DIM];
for (unsigned int x = 0; x < X; x++)
for (unsigned int y = 0; y < Y; y++)
for (unsigned int z = 0; z < Z; z++)
shift[(z * Z + y) * Y + x] = cexp(2.i * M_PI * ((csh[0] * x) / X + (csh[1] * y) / Y + (csh[2] * z) / Z));
md_zmul2(DIMS, msk_dims, msk_strs, pattern + size, msk_strs, pattern + size, shift_strs, shift);
md_free(shift);
}
#if 0
float scaling = 1. / estimate_scaling(ksp_dims, NULL, kspace_data);
#else
float scaling = 100. / md_znorm(DIMS, ksp_dims, kspace_data);
#endif
debug_printf(DP_INFO, "Scaling: %f\n", scaling);
md_zsmul(DIMS, ksp_dims, kspace_data, kspace_data, scaling);
if (-1. == restrict_fov) {
mask = md_alloc(DIMS, msk_dims, CFL_SIZE);
md_zfill(DIMS, msk_dims, mask, 1.);
} else {
float restrict_dims[DIMS] = { [0 ... DIMS - 1] = 1. };
restrict_dims[0] = restrict_fov;
restrict_dims[1] = restrict_fov;
restrict_dims[2] = restrict_fov;
mask = compute_mask(DIMS, msk_dims, restrict_dims);
}
#ifdef USE_CUDA
if (usegpu) {
complex float* kspace_gpu = md_alloc_gpu(DIMS, ksp_dims, CFL_SIZE);
md_copy(DIMS, ksp_dims, kspace_gpu, kspace_data, CFL_SIZE);
noir_recon(dims, iter, l1, image, NULL, pattern, mask, kspace_gpu, rvc, usegpu);
md_free(kspace_gpu);
md_zfill(DIMS, ksp_dims, sens, 1.);
} else
#endif
noir_recon(dims, iter, l1, image, sens, pattern, mask, kspace_data, rvc, usegpu);
if (normalize) {
md_zrss(DIMS, ksp_dims, COIL_FLAG, norm, sens);
md_zmul2(DIMS, img_dims, img_strs, image, img_strs, image, msk_strs, norm);
}
if (4 == argc) {
long strs[DIMS];
md_calc_strides(DIMS, strs, ksp_dims, CFL_SIZE);
if (norm)
md_zdiv2(DIMS, ksp_dims, strs, sens, strs, sens, img_strs, norm);
fftmod(DIMS, ksp_dims, FFT_FLAGS, sens, sens);
unmap_cfl(DIMS, ksp_dims, sens);
} else {
md_free(sens);
}
md_free(norm);
md_free(mask);
if (NULL != psf)
unmap_cfl(DIMS, pat_dims, pattern);
else
md_free(pattern);
unmap_cfl(DIMS, img_dims, image);
unmap_cfl(DIMS, ksp_dims, kspace_data);
exit(0);
}
int main_rsense(int argc, char* argv[])
{
bool usegpu = false;
int maps = 2;
int ctrsh = 0.;
bool sec = false;
bool scale_im = false;
const char* pat_file = NULL;
struct sense_conf sconf = sense_defaults;
struct grecon_conf conf = { NULL, &sconf, false, false, false, true, 30, 0.95, 0. };
int c;
while (-1 != (c = getopt(argc, argv, "l:r:s:i:p:Sgh"))) {
switch(c) {
case 'r':
conf.lambda = atof(optarg);
break;
case 's':
conf.step = atof(optarg);
break;
case 'i':
conf.maxiter = atoi(optarg);
break;
case 'l':
if (1 == atoi(optarg))
conf.l1wav = true;
else if (2 == atoi(optarg))
conf.l1wav = false;
else {
usage(argv[0], stderr);
exit(1);
}
break;
case 'S':
scale_im = true;
break;
case 'h':
usage(argv[0], stdout);
help();
exit(0);
case 'g':
usegpu = true;
break;
case 'p':
pat_file = strdup(optarg);
break;
default:
usage(argv[0], stderr);
exit(1);
}
}
if (argc - optind != 3) {
usage(argv[0], stderr);
exit(1);
}
int N = DIMS;
long dims[N];
long img_dims[N];
long ksp_dims[N];
long sens_dims[N];
complex float* kspace_data = load_cfl(argv[optind + 0], N, ksp_dims);
complex float* sens_maps = load_cfl(argv[optind + 1], N, sens_dims);
assert(1 == ksp_dims[MAPS_DIM]);
md_copy_dims(N, dims, ksp_dims);
if (!sec) {
dims[MAPS_DIM] = sens_dims[MAPS_DIM];
} else {
assert(maps <= ksp_dims[COIL_DIM]);
dims[MAPS_DIM] = maps;
}
for (int i = 0; i < 4; i++) { // sizes2[4] may be > 1
if (ksp_dims[i] != dims[i]) {
fprintf(stderr, "Dimensions of kspace and sensitivities do not match!\n");
exit(1);
}
}
complex float* pattern = NULL;
long pat_dims[DIMS];
if (NULL != pat_file) {
pattern = load_cfl(pat_file, DIMS, pat_dims);
assert(md_check_compat(DIMS, COIL_FLAG, ksp_dims, pat_dims));
}
debug_printf(DP_INFO, "%ld map(s)\n", dims[MAPS_DIM]);
if (conf.l1wav)
debug_printf(DP_INFO, "l1-wavelet regularization\n");
md_select_dims(N, ~COIL_FLAG, img_dims, dims);
(usegpu ? num_init_gpu : num_init)();
// float scaling = estimate_scaling(ksp_dims, sens_maps, kspace_data);
float scaling = estimate_scaling(ksp_dims, NULL, kspace_data);
debug_printf(DP_INFO, "Scaling: %f\n", scaling);
if (0. != scaling)
md_zsmul(N, ksp_dims, kspace_data, kspace_data, 1. / scaling);
debug_printf(DP_INFO, "Readout FFT..\n");
ifftuc(N, ksp_dims, READ_FLAG, kspace_data, kspace_data);
debug_printf(DP_INFO, "Done.\n");
complex float* image = create_cfl(argv[optind + 2], N, img_dims);
debug_printf(DP_INFO, "Reconstruction...\n");
struct ecalib_conf calib;
if (sec) {
calib = ecalib_defaults;
calib.crop = ctrsh;
conf.calib = &calib;
}
rgrecon(&conf, dims, image, sens_dims, sens_maps, pat_dims, pattern, kspace_data, usegpu);
if (scale_im)
md_zsmul(DIMS, img_dims, image, image, scaling);
debug_printf(DP_INFO, "Done.\n");
unmap_cfl(N, img_dims, image);
unmap_cfl(N, ksp_dims, kspace_data);
unmap_cfl(N, sens_dims, sens_maps);
exit(0);
}
