static void dfthresh(unsigned int D, const long dims[D], float lambda, complex float* out, const complex float* in)
{
long minsize[3];
md_singleton_dims(3, minsize);
long coarse_scale[3] = MD_INIT_ARRAY(3, 16);
md_min_dims(3, ~0u, minsize, dims, coarse_scale);
complex float res[3];
res[0] = 1.;
res[1] = 1.;
res[2] = 1.;
assert(3 == dims[TE_DIM]);
const struct operator_p_s* p = prox_dfwavelet_create(dims, minsize, res, TE_DIM, lambda, false);
operator_p_apply(p, 1., D, dims, out, D, dims, in);
operator_p_free(p);
}
// FIXME: consider moving this to a more accessible location?
static void wthresh(unsigned int D, const long dims[D], float lambda, unsigned int flags, complex float* out, const complex float* in)
{
long minsize[D];
md_singleton_dims(D, minsize);
long course_scale[3] = MD_INIT_ARRAY(3, 16);
md_copy_dims(3, minsize, course_scale);
unsigned int wflags = 7; // FIXME
for (unsigned int i = 0; i < 3; i++)
if (dims[i] < minsize[i])
wflags = MD_CLEAR(wflags, i);
long strs[D];
md_calc_strides(D, strs, dims, CFL_SIZE);
const struct linop_s* w = linop_wavelet_create(D, wflags, dims, strs, minsize, false);
const struct operator_p_s* p = prox_unithresh_create(D, w, lambda, flags);
operator_p_apply(p, 1., D, dims, out, D, dims, in);
operator_p_free(p);
}
int main_bench(int argc, char* argv[])
{
int c;
bool threads = false;
bool scaling = false;
while (-1 != (c = getopt(argc, argv, "TSh"))) {
switch (c) {
case 'T':
threads = true;
break;
case 'S':
scaling = true;
break;
case 'h':
usage(argv[0], stdout);
help();
exit(0);
default:
usage(argv[0], stderr);
exit(1);
}
}
if (argc - optind > 1) {
usage(argv[0], stderr);
exit(1);
}
long dims[BENCH_DIMS] = MD_INIT_ARRAY(BENCH_DIMS, 1);
long strs[BENCH_DIMS];
long pos[BENCH_DIMS] = { 0 };
dims[REPETITION_IND] = 5;
dims[THREADS_IND] = threads ? 8 : 1;
dims[SCALE_IND] = scaling ? 5 : 1;
dims[TESTS_IND] = sizeof(benchmarks) / sizeof(benchmarks[0]);
md_calc_strides(BENCH_DIMS, strs, dims, CFL_SIZE);
bool outp = (1 == argc - optind);
complex float* out = (outp ? create_cfl : anon_cfl)(outp ? argv[optind] : "", BENCH_DIMS, dims);
num_init();
do {
if (threads) {
num_set_num_threads(pos[THREADS_IND] + 1);
debug_printf(DP_INFO, "%02d threads. ", pos[THREADS_IND] + 1);
}
do_test(dims, &MD_ACCESS(BENCH_DIMS, strs, pos, out), pos[SCALE_IND] + 1,
benchmarks[pos[TESTS_IND]].fun, benchmarks[pos[TESTS_IND]].str);
} while (md_next(BENCH_DIMS, dims, ~MD_BIT(REPETITION_IND), pos));
unmap_cfl(BENCH_DIMS, dims, out);
exit(0);
}
void calib2(const struct ecalib_conf* conf, const long out_dims[DIMS], complex float* out_data, complex float* eptr, unsigned int SN, float svals[SN], const long calreg_dims[DIMS], const complex float* data, const long msk_dims[3], const bool* msk)
{
long channels = calreg_dims[3];
long maps = out_dims[4];
assert(calreg_dims[3] == out_dims[3]);
assert(maps <= channels);
assert(1 == md_calc_size(DIMS - 5, out_dims + 5));
assert(1 == md_calc_size(DIMS - 5, calreg_dims + 5));
complex float rot[channels][channels];
if (conf->rotphase) {
long scc_dims[DIMS] = MD_INIT_ARRAY(DIMS, 1);
scc_dims[COIL_DIM] = channels;
scc_dims[MAPS_DIM] = channels;
scc(scc_dims, &rot[0][0], calreg_dims, data);
} else {
for (unsigned int i = 0; i < channels; i++)
for (unsigned int j = 0; j < channels; j++)
rot[i][j] = (i == j) ? 1. : 0.;
}
long cov_dims[4];
calone_dims(conf, cov_dims, channels);
complex float* imgcov = md_alloc(4, cov_dims, CFL_SIZE);
calone(conf, cov_dims, imgcov, SN, svals, calreg_dims, data);
caltwo(conf, out_dims, out_data, eptr, cov_dims, imgcov, msk_dims, msk);
/* Intensity and phase normalization similar as proposed
* for adaptive combine (Walsh's method) in
* Griswold et al., ISMRM 10:2410 (2002)
*/
if (conf->intensity) {
debug_printf(DP_DEBUG1, "Normalize...\n");
/* I think the reason this works is because inhomogeneity usually
* comes from only a few coil elements which are close. The l1-norm
* is more resilient against such outliers. -- Martin
*/
normalizel1(DIMS, COIL_FLAG, out_dims, out_data);
md_zsmul(DIMS, out_dims, out_data, out_data, sqrtf((float)channels));
}
debug_printf(DP_DEBUG1, "Crop maps... (%.2f)\n", conf->crop);
crop_sens(out_dims, out_data, conf->softcrop, conf->crop, eptr);
debug_printf(DP_DEBUG1, "Fix phase...\n");
// rotate the the phase with respect to the first principle component
fixphase2(DIMS, out_dims, COIL_DIM, rot[0], out_data, out_data);
md_free(imgcov);
}
