static struct linop_s* linop_fft_create_priv(int N, const long dims[N], unsigned int flags, bool forward, bool center)
{
const struct operator_s* plan = fft_measure_create(N, dims, flags, true, false);
const struct operator_s* iplan = fft_measure_create(N, dims, flags, true, true);
PTR_ALLOC(struct fft_linop_s, data);
SET_TYPEID(fft_linop_s, data);
data->frw = plan;
data->adj = iplan;
data->N = N;
data->center = center;
data->dims = *TYPE_ALLOC(long[N]);
md_copy_dims(N, data->dims, dims);
data->strs = *TYPE_ALLOC(long[N]);
md_calc_strides(N, data->strs, data->dims, CFL_SIZE);
long fft_dims[N];
md_select_dims(N, flags, fft_dims, dims);
data->nscale = (float)md_calc_size(N, fft_dims);
lop_fun_t apply = forward ? fft_linop_apply : fft_linop_adjoint;
lop_fun_t adjoint = forward ? fft_linop_adjoint : fft_linop_apply;
struct linop_s* lop = linop_create(N, dims, N, dims, CAST_UP(PTR_PASS(data)), apply, adjoint, fft_linop_normal, NULL, fft_linop_free);
if (center) {
// FIXME: should only allocate flagged dims
complex float* fftmod_mat = md_alloc(N, dims, CFL_SIZE);
complex float* fftmodk_mat = md_alloc(N, dims, CFL_SIZE);
// we need fftmodk only because we want to apply scaling only once
complex float one[1] = { 1. };
md_fill(N, dims, fftmod_mat, one, CFL_SIZE);
fftmod(N, dims, flags, fftmodk_mat, fftmod_mat);
fftscale(N, dims, flags, fftmod_mat, fftmodk_mat);
struct linop_s* mod = linop_cdiag_create(N, dims, ~0u, fftmod_mat);
struct linop_s* modk = linop_cdiag_create(N, dims, ~0u, fftmodk_mat);
struct linop_s* tmp = linop_chain(mod, lop);
tmp = linop_chain(tmp, modk);
linop_free(lop);
linop_free(mod);
linop_free(modk);
lop = tmp;
}
return lop;
}
const struct operator_s* sense_recon_create(const struct sense_conf* conf, const long dims[DIMS],
const struct linop_s* sense_op,
const long pat_dims[DIMS], const complex float* pattern,
italgo_fun2_t italgo, iter_conf* iconf,
unsigned int num_funs,
const struct operator_p_s* thresh_op[num_funs],
const struct linop_s* thresh_funs[num_funs],
const long ksp_dims[DIMS],
const struct operator_s* precond_op)
{
struct lsqr_conf lsqr_conf = { conf->cclambda };
const struct operator_s* op = NULL;
long img_dims[DIMS];
md_select_dims(DIMS, ~COIL_FLAG, img_dims, dims);
if (conf->rvc) {
struct linop_s* rvc = rvc_create(DIMS, img_dims);
struct linop_s* tmp_op = linop_chain(rvc, sense_op);
linop_free(rvc);
linop_free(sense_op);
sense_op = tmp_op;
}
assert(1 == conf->rwiter);
if (NULL == pattern) {
op = lsqr2_create(&lsqr_conf, italgo, iconf, sense_op, precond_op,
num_funs, thresh_op, thresh_funs);
} else {
complex float* weights = md_alloc(DIMS, pat_dims, CFL_SIZE); // FIXME: GPU
#if 0
// buggy
// md_zsqrt(DIMS, pat_dims, weights, pattern);
#else
long dimsR[DIMS + 1];
real_from_complex_dims(DIMS, dimsR, pat_dims);
md_sqrt(DIMS + 1, dimsR, (float*)weights, (const float*)pattern);
#endif
struct linop_s* weights_op = linop_cdiag_create(DIMS, ksp_dims, FFT_FLAGS, weights); // FIXME: check pat_dims
op = wlsqr2_create(&lsqr_conf, italgo, iconf,
sense_op, weights_op, precond_op,
num_funs, thresh_op, thresh_funs);
}
return op;
}
static void nufft_free_data(const void* _data)
{
struct nufft_data* data = (struct nufft_data*)_data;
free(data->ksp_dims);
free(data->cim_dims);
free(data->cml_dims);
free(data->img_dims);
free(data->trj_dims);
free(data->lph_dims);
free(data->psf_dims);
free(data->wgh_dims);
free(data->ksp_strs);
free(data->cim_strs);
free(data->cml_strs);
free(data->img_strs);
free(data->trj_strs);
free(data->lph_strs);
free(data->psf_strs);
free(data->wgh_strs);
md_free(data->grid);
md_free((void*)data->linphase);
md_free((void*)data->psf);
md_free((void*)data->fftmod);
md_free((void*)data->weights);
linop_free(data->fft_op);
free(data);
}
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;
}
/**
* Create sense operator, y = F S x,
* where F is the Fourier transform and S is the sensitivity maps
*
* @param max_dims maximal dimensions across all data structures
* @param sens_flags active map dimensions
* @param sens sensitivities
* @param gpu TRUE if using gpu
*/
struct linop_s* sense_init(const long max_dims[DIMS],
unsigned int sens_flags, const complex float* sens, bool gpu)
{
long ksp_dims[DIMS];
md_select_dims(DIMS, ~MAPS_FLAG, ksp_dims, max_dims);
struct linop_s* fft = linop_fft_create(DIMS, ksp_dims, FFT_FLAGS, gpu);
struct linop_s* maps = maps_create(max_dims, sens_flags, sens, gpu);
struct linop_s* sense_op = linop_chain(maps, fft);
linop_free(fft);
linop_free(maps);
return sense_op;
}
static void ufft_free_data(const linop_data_t* _data)
{
struct ufft_data* data = CONTAINER_OF(_data, struct ufft_data, base);
md_free(data->pat);
linop_free(data->fft_op);
free((void*)data);
}
static void ufft_free_data(const linop_data_t* _data)
{
struct ufft_data* data = CAST_DOWN(ufft_data, _data);
md_free(data->pat);
linop_free(data->fft_op);
xfree(data);
}
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;
}
void iter_admm(iter_conf* _conf,
const struct operator_s* normaleq_op,
const struct operator_p_s* thresh_prox,
long size, float* image, const float* image_adj,
struct iter_monitor_s* monitor)
{
const struct linop_s* eye[1] = { linop_identity_create(1, MD_DIMS(size / 2)) }; // using complex float identity operator... divide size by 2
iter2_admm(_conf, normaleq_op, 1, &thresh_prox, eye, NULL, NULL, size, image, image_adj, monitor);
linop_free(eye[0]);
}
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;
}
void iter_admm(iter_conf* _conf,
const struct operator_s* normaleq_op,
const struct operator_p_s* thresh_prox,
long size, float* image, const float* image_adj,
const float* image_truth,
void* objval_data,
float (*obj_eval)(const void*, const float*))
{
const struct linop_s* eye[1] = { linop_identity_create(1, MD_DIMS(size / 2)) }; // using complex float identity operator... divide size by 2
iter2_admm(_conf, normaleq_op, 1, &thresh_prox, eye, NULL, size, image, image_adj, image_truth, objval_data, obj_eval);
linop_free(eye[0]);
}
static void prox_4pt_dfwavelet_del(const operator_data_t* _data)
{
struct prox_4pt_dfwavelet_data* data = CONTAINER_OF(_data, struct prox_4pt_dfwavelet_data, base);
md_free(data->vx);
md_free(data->vy);
md_free(data->vz);
md_free(data->ph0);
md_free(data->pc0);
md_free(data->pc1);
md_free(data->pc2);
md_free(data->pc3);
dfwavelet_free(data->plan);
operator_p_free(data->wthresh_op);
linop_free(data->w_op);
free(data);
}
void opt_reg_configure(unsigned int N, const long img_dims[N], struct opt_reg_s* ropts, const struct operator_p_s* prox_ops[NUM_REGS], const struct linop_s* trafos[NUM_REGS], unsigned int llr_blk, bool randshift, bool use_gpu)
{
float lambda = ropts->lambda;
if (-1. == lambda)
lambda = 0.;
// if no penalities specified but regularization
// parameter is given, add a l2 penalty
struct reg_s* regs = ropts->regs;
if ((0 == ropts->r) && (lambda > 0.)) {
regs[0].xform = L2IMG;
regs[0].xflags = 0u;
regs[0].jflags = 0u;
regs[0].lambda = lambda;
ropts->r = 1;
}
int nr_penalties = ropts->r;
long blkdims[MAX_LEV][DIMS];
int levels;
for (int nr = 0; nr < nr_penalties; nr++) {
// fix up regularization parameter
if (-1. == regs[nr].lambda)
regs[nr].lambda = lambda;
switch (regs[nr].xform) {
case L1WAV:
debug_printf(DP_INFO, "l1-wavelet regularization: %f\n", regs[nr].lambda);
if (0 != regs[nr].jflags)
debug_printf(DP_WARN, "joint l1-wavelet thresholding not currently supported.\n");
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);
unsigned int wflags = 0;
for (unsigned int i = 0; i < DIMS; i++) {
if ((1 < img_dims[i]) && MD_IS_SET(regs[nr].xflags, i)) {
wflags = MD_SET(wflags, i);
minsize[i] = MIN(img_dims[i], 16);
}
}
trafos[nr] = linop_identity_create(DIMS, img_dims);
prox_ops[nr] = prox_wavelet3_thresh_create(DIMS, img_dims, wflags, minsize, regs[nr].lambda, randshift);
break;
case TV:
debug_printf(DP_INFO, "TV regularization: %f\n", regs[nr].lambda);
trafos[nr] = linop_grad_create(DIMS, img_dims, regs[nr].xflags);
prox_ops[nr] = prox_thresh_create(DIMS + 1,
linop_codomain(trafos[nr])->dims,
regs[nr].lambda, regs[nr].jflags | MD_BIT(DIMS), use_gpu);
break;
case LLR:
debug_printf(DP_INFO, "lowrank regularization: %f\n", regs[nr].lambda);
// add locally lowrank penalty
levels = llr_blkdims(blkdims, regs[nr].jflags, img_dims, llr_blk);
assert(1 == levels);
assert(levels == img_dims[LEVEL_DIM]);
for(int l = 0; l < levels; l++)
#if 0
blkdims[l][MAPS_DIM] = img_dims[MAPS_DIM];
#else
blkdims[l][MAPS_DIM] = 1;
#endif
int remove_mean = 0;
trafos[nr] = linop_identity_create(DIMS, img_dims);
prox_ops[nr] = lrthresh_create(img_dims, randshift, regs[nr].xflags, (const long (*)[DIMS])blkdims, regs[nr].lambda, false, remove_mean, use_gpu);
break;
case MLR:
#if 0
// FIXME: multiscale low rank changes the output image dimensions
// and requires the forward linear operator. This should be decoupled...
debug_printf(DP_INFO, "multi-scale lowrank regularization: %f\n", regs[nr].lambda);
levels = multilr_blkdims(blkdims, regs[nr].jflags, img_dims, 8, 1);
img_dims[LEVEL_DIM] = levels;
max_dims[LEVEL_DIM] = levels;
for(int l = 0; l < levels; l++)
blkdims[l][MAPS_DIM] = 1;
trafos[nr] = linop_identity_create(DIMS, img_dims);
prox_ops[nr] = lrthresh_create(img_dims, randshift, regs[nr].xflags, (const long (*)[DIMS])blkdims, regs[nr].lambda, false, 0, use_gpu);
const struct linop_s* decom_op = sum_create( img_dims, use_gpu );
const struct linop_s* tmp_op = forward_op;
forward_op = linop_chain(decom_op, forward_op);
linop_free(decom_op);
linop_free(tmp_op);
#else
debug_printf(DP_WARN, "multi-scale lowrank regularization not yet supported: %f\n", regs[nr].lambda);
#endif
break;
case IMAGL1:
debug_printf(DP_INFO, "l1 regularization of imaginary part: %f\n", regs[nr].lambda);
trafos[nr] = linop_rdiag_create(DIMS, img_dims, 0, &(complex float){ 1.i });
prox_ops[nr] = prox_thresh_create(DIMS, img_dims, regs[nr].lambda, regs[nr].jflags, use_gpu);
break;
case IMAGL2:
debug_printf(DP_INFO, "l2 regularization of imaginary part: %f\n", regs[nr].lambda);
trafos[nr] = linop_rdiag_create(DIMS, img_dims, 0, &(complex float){ 1.i });
prox_ops[nr] = prox_leastsquares_create(DIMS, img_dims, regs[nr].lambda, NULL);
break;
case L1IMG:
debug_printf(DP_INFO, "l1 regularization: %f\n", regs[nr].lambda);
trafos[nr] = linop_identity_create(DIMS, img_dims);
prox_ops[nr] = prox_thresh_create(DIMS, img_dims, regs[nr].lambda, regs[nr].jflags, use_gpu);
break;
case L2IMG:
debug_printf(DP_INFO, "l2 regularization: %f\n", regs[nr].lambda);
trafos[nr] = linop_identity_create(DIMS, img_dims);
prox_ops[nr] = prox_leastsquares_create(DIMS, img_dims, regs[nr].lambda, NULL);
break;
case FTL1:
debug_printf(DP_INFO, "l1 regularization of Fourier transform: %f\n", regs[nr].lambda);
trafos[nr] = linop_fft_create(DIMS, img_dims, regs[nr].xflags);
prox_ops[nr] = prox_thresh_create(DIMS, img_dims, regs[nr].lambda, regs[nr].jflags, use_gpu);
break;
}
