static void homodyne(struct wdata wdata, unsigned int flags, unsigned int N, const long dims[N],
const long strs[N], complex float* data, const complex float* idata)
{
long cdims[N];
md_copy_dims(N, cdims, dims);
// cdims[0] = cdims[1] = cdims[2] = 24;
cdims[wdata.pfdim] = (wdata.frac - 0.5) * dims[wdata.pfdim];
complex float* center = md_alloc(N, cdims, CFL_SIZE);
complex float* phase = md_alloc(N, dims, CFL_SIZE);
md_resize_center(N, cdims, center, dims, idata, CFL_SIZE);
md_resize_center(N, dims, phase, cdims, center, CFL_SIZE);
md_free(center);
ifftuc(N, dims, flags, phase, phase);
md_zphsr(N, dims, phase, phase);
md_zmul2(N, dims, strs, data, strs, idata, wdata.wstrs, wdata.weights);
ifftuc(N, dims, flags, data, data);
md_zmulc(N, dims, data, data, phase);
md_zreal(N, dims, data, data);
md_free(phase);
}
static complex float* estimate_phase(struct wdata wdata, unsigned int flags,
unsigned int N, const long dims[N], const complex float* idata)
{
long cdims[N];
md_copy_dims(N, cdims, dims);
// cdims[0] = cdims[1] = cdims[2] = 24;
cdims[wdata.pfdim] = (wdata.frac - 0.5) * dims[wdata.pfdim];
complex float* center = md_alloc(N, cdims, CFL_SIZE);
complex float* phase = md_alloc(N, dims, CFL_SIZE);
md_resize_center(N, cdims, center, dims, idata, CFL_SIZE);
md_resize_center(N, dims, phase, cdims, center, CFL_SIZE);
md_free(center);
ifftuc(N, dims, flags, phase, phase);
md_zphsr(N, dims, phase, phase);
return phase;
}
void direct_calib(const long dims[5], complex float* sens, const long caldims[5], const complex float* data)
{
complex float* tmp = md_alloc(5, caldims, CFL_SIZE);
assert(1 == caldims[4]);
assert(1 == dims[4]);
md_copy(5, caldims, tmp, data, CFL_SIZE);
// apply Kaiser-Bessel Window beta=4
for (int z = 0; z < caldims[2]; z++)
for (int y = 0; y < caldims[1]; y++)
for (int x = 0; x < caldims[0]; x++)
for (int c = 0; c < caldims[3]; c++)
tmp[((c * caldims[2] + z) * caldims[1] + y) * caldims[0] + x]
*= kaiser(4., caldims[2], z)
* kaiser(4., caldims[1], y)
* kaiser(4., caldims[0], x);
md_resize_center(5, dims, sens, caldims, tmp, CFL_SIZE);
ifftc(5, dims, 7, sens, sens);
long dims1[5];
md_select_dims(5, ~MD_BIT(COIL_DIM), dims1, dims);
complex float* img = md_alloc(5, dims1, CFL_SIZE);
md_zrss(5, dims, COIL_FLAG, img, sens);
#if 1
long T = md_calc_size(5, dims1);
for (int i = 0; i < T; i++)
for (int j = 0; j < dims[COIL_DIM]; j++)
sens[j * T + i] *= (cabs(img[i]) == 0.) ? 0. : (1. / cabs(img[i]));
#endif
md_free(img);
}
static void resize_adjoint(const linop_data_t* _data, complex float* dst, const complex float* src)
{
const struct resize_op_s* data = CAST_DOWN(resize_op_s, _data);
md_resize_center(data->N, data->in_dims, dst, data->out_dims, src, CFL_SIZE);
}
void walsh(const long bsize[3], const long dims[DIMS], complex float* sens, const long caldims[DIMS], const complex float* data)
{
assert(1 == caldims[MAPS_DIM]);
assert(1 == dims[MAPS_DIM]);
int channels = caldims[COIL_DIM];
int cosize = channels * (channels + 1) / 2;
assert(dims[COIL_DIM] == cosize);
long dims1[DIMS];
md_copy_dims(DIMS, dims1, dims);
dims1[COIL_DIM] = channels;
long kdims[4];
kdims[0] = MIN(bsize[0], dims[0]);
kdims[1] = MIN(bsize[1], dims[1]);
kdims[2] = MIN(bsize[2], dims[2]);
md_resize_center(DIMS, dims1, sens, caldims, data, CFL_SIZE);
ifftc(DIMS, dims1, FFT_FLAGS, sens, sens);
long odims[DIMS];
md_copy_dims(DIMS, odims, dims1);
for (int i = 0; i < 3; i++)
odims[i] = dims[i] + kdims[i] - 1;
complex float* tmp = md_alloc(DIMS, odims, CFL_SIZE);
#if 0
md_resizec(DIMS, odims, tmp, dims1, sens, CFL_SIZE);
#else
long cen[DIMS] = { 0 };
for (int i = 0; i < 3; i++)
cen[i] = (odims[i] - dims[i] + 1) / 2;
complex float* tmp1 = md_alloc(DIMS, odims, CFL_SIZE);
md_circ_ext(DIMS, odims, tmp1, dims1, sens, CFL_SIZE);
// md_resize(DIMS, odims, tmp1, dims1, sens, CFL_SIZE);
md_circ_shift(DIMS, odims, cen, tmp, tmp1, CFL_SIZE);
md_free(tmp1);
#endif
long calmat_dims[2];
complex float* cm = calibration_matrix(calmat_dims, kdims, odims, tmp);
md_free(tmp);
int xh = dims[0];
int yh = dims[1];
int zh = dims[2];
int pixels = calmat_dims[1] / channels;
#pragma omp parallel for
for (int k = 0; k < zh; k++) {
complex float in[channels][pixels];
complex float cov[cosize];
for (int j = 0; j < yh; j++) {
for (int i = 0; i < xh; i++) {
for (int c = 0; c < channels; c++)
for (int p = 0; p < pixels; p++)
in[c][p] = cm[((((c * pixels + p) * zh) + k) * yh + j) * xh + i];
gram_matrix2(channels, cov, pixels, in);
for (int l = 0; l < cosize; l++)
sens[(((l * zh) + k) * yh + j) * xh + i] = cov[l];
}
}
}
}
void overlapandsave2NE(int N, unsigned int flags, const long blk[N], const long odims[N], complex float* dst, const long dims1[N], complex float* src1, const long dims2[N], complex float* src2, const long mdims[N], complex float* msk)
{
long dims1B[N];
long tdims[2 * N];
long nodims[2 * N];
long ndims1[2 * N];
long ndims2[2 * N];
long shift[2 * N];
unsigned int nflags = 0;
for (int i = 0; i < N; i++) {
if (MD_IS_SET(flags, i)) {
nflags = MD_SET(nflags, 2 * i);
assert(1 == dims2[i] % 2);
assert(0 == blk[i] % 2);
assert(0 == dims1[i] % 2);
assert(0 == odims[i] % blk[i]);
assert(0 == dims1[i] % blk[i]);
assert(dims1[i] == odims[i]);
assert(dims2[i] <= blk[i]);
assert(dims1[i] >= dims2[i]);
// blocked output
nodims[i * 2 + 1] = odims[i] / blk[i];
nodims[i * 2 + 0] = blk[i];
// expanded temporary storage
tdims[i * 2 + 1] = dims1[i] / blk[i];
tdims[i * 2 + 0] = blk[i] + dims2[i] - 1;
// blocked input
// ---|---,---,---|---
// + +++ +
// + +++ +
// resized input
dims1B[i] = dims1[i] + 2 * blk[i];
ndims1[i * 2 + 1] = dims1[i] / blk[i] + 2; // do we need two full blocks?
ndims1[i * 2 + 0] = blk[i];
shift[i * 2 + 1] = 0;
shift[i * 2 + 0] = blk[i] - (dims2[i] - 1) / 2;
// kernel
ndims2[i * 2 + 1] = 1;
ndims2[i * 2 + 0] = dims2[i];
} else {
nodims[i * 2 + 1] = 1;
nodims[i * 2 + 0] = odims[i];
tdims[i * 2 + 1] = 1;
tdims[i * 2 + 0] = dims1[i];
ndims1[i * 2 + 1] = 1;
ndims1[i * 2 + 0] = dims1[i];
shift[i * 2 + 1] = 0;
shift[i * 2 + 0] = 0;
dims1B[i] = dims1[i];
ndims2[i * 2 + 1] = 1;
ndims2[i * 2 + 0] = dims2[i];
}
}
complex float* src1B = md_alloc(N, dims1B, CFL_SIZE);
complex float* tmp = md_alloc(2 * N, tdims, CFL_SIZE);
complex float* tmpX = md_alloc(N, odims, CFL_SIZE);
long str1[2 * N];
long str2[2 * N];
md_calc_strides(2 * N, str1, ndims1, sizeof(complex float));
md_calc_strides(2 * N, str2, tdims, sizeof(complex float));
long off = md_calc_offset(2 * N, str1, shift);
md_resize_center(N, dims1B, src1B, dims1, src1, sizeof(complex float));
// we can loop here
md_copy2(2 * N, tdims, str2, tmp, str1, ((void*)src1B) + off, sizeof(complex float));
conv(2 * N, nflags, CONV_VALID, CONV_SYMMETRIC, nodims, tmpX, tdims, tmp, ndims2, src2);
long ostr[N];
long mstr[N];
md_calc_strides(N, ostr, odims, sizeof(complex float));
md_calc_strides(N, mstr, mdims, sizeof(complex float));
md_zmul2(N, odims, ostr, tmpX, ostr, tmpX, mstr, msk);
convH(2 * N, nflags, CONV_VALID, CONV_SYMMETRIC, tdims, tmp, nodims, tmpX, ndims2, src2);
md_clear(N, dims1B, src1B, sizeof(complex float));
md_zadd2(2 * N, tdims, str1, ((void*)src1B) + off, str1, ((void*)src1B) + off, str2, tmp);
//
md_resize_center(N, dims1, dst, dims1B, src1B, sizeof(complex float));
md_free(src1B);
md_free(tmpX);
md_free(tmp);
}
static void resize_adjoint(const void* _data, complex float* dst, const complex float* src)
{
const struct resize_op_s* data = _data;
md_resize_center(data->N, data->in_dims, dst, data->out_dims, src, CFL_SIZE);
}
int main_ecalib(int argc, char* argv[])
{
long calsize[3] = { 24, 24, 24 };
int maps = 2;
bool one = false;
bool calcen = false;
bool print_svals = false;
struct ecalib_conf conf = ecalib_defaults;
const struct opt_s opts[] = {
OPT_FLOAT('t', &conf.threshold, "threshold", "This determined the size of the null-space."),
OPT_FLOAT('c', &conf.crop, "crop_value", "Crop the sensitivities if the eigenvalue is smaller than {crop_value}."),
OPT_VEC3('k', &conf.kdims, "ksize", "kernel size"),
OPT_VEC3('K', &conf.kdims, "", "()"),
OPT_VEC3('r', &calsize, "cal_size", "Limits the size of the calibration region."),
OPT_VEC3('R', &calsize, "", "()"),
OPT_INT('m', &maps, "maps", "Number of maps to compute."),
OPT_SET('S', &conf.softcrop, "create maps with smooth transitions (Soft-SENSE)."),
OPT_SET('W', &conf.weighting, "soft-weighting of the singular vectors."),
OPT_SET('I', &conf.intensity, "intensity correction"),
OPT_SET('1', &one, "perform only first part of the calibration"),
OPT_CLEAR('P', &conf.rotphase, "Do not rotate the phase with respect to the first principal component"),
OPT_CLEAR('O', &conf.orthiter, "()"),
OPT_FLOAT('b', &conf.perturb, "", "()"),
OPT_SET('V', &print_svals, "()"),
OPT_SET('C', &calcen, "()"),
OPT_SET('g', &conf.usegpu, "()"),
OPT_FLOAT('p', &conf.percentsv, "", "()"),
OPT_INT('n', &conf.numsv, "", "()"),
OPT_FLOAT('v', &conf.var, "variance", "Variance of noise in data."),
OPT_SET('a', &conf.automate, "Automatically pick thresholds."),
OPT_INT('d', &debug_level, "level", "Debug level"),
};
cmdline(&argc, argv, 2, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
if (-1. != conf.percentsv)
conf.threshold = -1.;
if (-1 != conf.numsv)
conf.threshold = -1.;
if (conf.automate) {
conf.crop = -1.;
conf.weighting = true;
}
if (conf.weighting) {
conf.numsv = -1.;
conf.threshold = 0;
conf.percentsv = -1.;
conf.orthiter = false;
}
int N = DIMS;
long ksp_dims[N];
complex float* in_data = load_cfl(argv[1], N, ksp_dims);
// assert((kdims[0] < calsize_ro) && (kdims[1] < calsize_ro) && (kdims[2] < calsize_ro));
// assert((ksp_dims[0] == 1) || (calsize_ro < ksp_dims[0]));
if (1 != ksp_dims[MAPS_DIM])
error("MAPS dimension is not of size one.\n");
long cal_dims[N];
complex float* cal_data = NULL;
if (!calcen) {
#ifdef USE_CC_EXTRACT_CALIB
cal_data = cc_extract_calib(cal_dims, calsize, ksp_dims, in_data);
#else
cal_data = extract_calib(cal_dims, calsize, ksp_dims, in_data, false);
#endif
} else {
for (int i = 0; i < 3; i++)
cal_dims[i] = (calsize[i] < ksp_dims[i]) ? calsize[i] : ksp_dims[i];
for (int i = 3; i < N; i++)
cal_dims[i] = ksp_dims[i];
cal_data = md_alloc(5, cal_dims, CFL_SIZE);
md_resize_center(5, cal_dims, cal_data, ksp_dims, in_data, CFL_SIZE);
}
for (int i = 0; i < 3; i++)
if (1 == ksp_dims[i])
conf.kdims[i] = 1;
long channels = cal_dims[3];
unsigned int K = conf.kdims[0] * conf.kdims[1] * conf.kdims[2] * channels;
float svals[K];
for (unsigned int i = 0; i < 3; i++)
if ((1 == cal_dims[i]) && (1 != ksp_dims[i]))
error("Calibration region not found!\n");
// To reproduce old results turn off rotation of phase.
// conf.rotphase = false;
// FIXME: we should scale the data
(conf.usegpu ? num_init_gpu : num_init)();
if ((conf.var < 0) && (conf.weighting || (conf.crop < 0)))
conf.var = estvar_calreg(conf.kdims, cal_dims, cal_data);
if (one) {
#if 0
long maps = out_dims[4];
assert(caldims[3] == out_dims[3]);
assert(maps <= channels);
#endif
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, K, svals, cal_dims, cal_data);
complex float* out = create_cfl(argv[2], 4, cov_dims);
md_copy(4, cov_dims, out, imgcov, CFL_SIZE);
unmap_cfl(4, cov_dims, out);
// caltwo(crthr, out_dims, out_data, emaps, cov_dims, imgcov, NULL, NULL);
md_free(imgcov);
} else {
long out_dims[N];
long map_dims[N];
for (int i = 0; i < N; i++) {
out_dims[i] = 1;
map_dims[i] = 1;
if ((i < 3) && (1 < conf.kdims[i])) {
out_dims[i] = ksp_dims[i];
map_dims[i] = ksp_dims[i];
}
}
assert(maps <= ksp_dims[COIL_DIM]);
out_dims[COIL_DIM] = ksp_dims[COIL_DIM];
out_dims[MAPS_DIM] = maps;
map_dims[COIL_DIM] = 1;
map_dims[MAPS_DIM] = maps;
const char* emaps_file = NULL;
if (4 == argc)
emaps_file = argv[3];
complex float* out_data = create_cfl(argv[2], N, out_dims);
complex float* emaps = (emaps_file ? create_cfl : anon_cfl)(emaps_file, N, map_dims);
calib(&conf, out_dims, out_data, emaps, K, svals, cal_dims, cal_data);
unmap_cfl(N, out_dims, out_data);
unmap_cfl(N, map_dims, emaps);
}
if (print_svals) {
for (unsigned int i = 0; i < K; i++)
printf("SVALS %d %f\n", i, svals[i]);
}
printf("Done.\n");
unmap_cfl(N, ksp_dims, in_data);
md_free(cal_data);
return 0;
}
void compute_imgcov(const long cov_dims[4], complex float* imgcov, const long nskerns_dims[5], const complex float* nskerns)
{
debug_printf(DP_DEBUG1, "Zeropad...\n");
long xh = cov_dims[0];
long yh = cov_dims[1];
long zh = cov_dims[2];
long kx = nskerns_dims[0];
long ky = nskerns_dims[1];
long kz = nskerns_dims[2];
long channels = nskerns_dims[3];
long nr_kernels = nskerns_dims[4];
long imgkern_dims[5] = { xh, yh, zh, channels, nr_kernels };
complex float* imgkern1 = md_alloc(5, imgkern_dims, CFL_SIZE);
complex float* imgkern2 = md_alloc(5, imgkern_dims, CFL_SIZE);
md_resize_center(5, imgkern_dims, imgkern1, nskerns_dims, nskerns, CFL_SIZE);
// resort array
debug_printf(DP_DEBUG1, "FFT (juggling)...\n");
long istr[5];
long mstr[5];
long idim[5] = { xh, yh, zh, channels, nr_kernels };
long mdim[5] = { nr_kernels, channels, xh, yh, zh };
md_calc_strides(5, istr, idim, CFL_SIZE);
md_calc_strides(5, mstr, mdim, CFL_SIZE);
long m2str[5] = { mstr[2], mstr[3], mstr[4], mstr[1], mstr[0] };
ifftmod(5, imgkern_dims, FFT_FLAGS, imgkern1, imgkern1);
ifft2(5, imgkern_dims, FFT_FLAGS, m2str, imgkern2, istr, imgkern1);
float scalesq = (kx * ky * kz) * (xh * yh * zh); // second part for FFT scaling
md_free(imgkern1);
debug_printf(DP_DEBUG1, "Calculate Gram matrix...\n");
int cosize = channels * (channels + 1) / 2;
assert(cov_dims[3] == cosize);
#pragma omp parallel for collapse(3)
for (int k = 0; k < zh; k++) {
for (int j = 0; j < yh; j++) {
for (int i = 0; i < xh; i++) {
complex float gram[cosize];
gram_matrix2(channels, gram, nr_kernels, (const complex float (*)[nr_kernels])(imgkern2 + ((k * yh + j) * xh + i) * (channels * nr_kernels)));
#ifdef FLIP
// add (scaled) identity matrix
for (int i = 0, l = 0; i < channels; i++)
for (int j = 0; j <= i; j++, l++)
gram[l] = ((i == j) ? (kx * ky * kz) : 0.) - gram[l];
#endif
for (int l = 0; l < cosize; l++)
imgcov[(((l * zh) + k) * yh + j) * xh + i] = gram[l] / scalesq;
}
}
}
md_free(imgkern2);
}