static void sense_adjoint(const void* _data, complex float* imgs, const complex float* out)
{
const struct sense_data* data = _data;
md_zmulc2(DIMS, data->data_dims, data->data_strs, data->tmp, data->data_strs, out, data->mask_strs, data->pattern);
ifftc(DIMS, data->data_dims, FFT_FLAGS, data->tmp, data->tmp);
fftscale(DIMS, data->data_dims, FFT_FLAGS, data->tmp, data->tmp);
md_clear(DIMS, data->imgs_dims, imgs, CFL_SIZE);
md_zfmacc2(DIMS, data->sens_dims, data->imgs_strs, imgs, data->data_strs, data->tmp, data->sens_strs, data->sens);
}
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);
}
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 ifftuc(unsigned int D, const long dimensions[__VLA(D)], unsigned long flags, complex float* dst, const complex float* src)
{
ifftc(D, dimensions, flags, dst, src);
fftscale(D, dimensions, flags, dst, dst);
}
