int main_transpose(int argc, char* argv[])
{
mini_cmdline(argc, argv, 4, usage_str, help_str);
int N = DIMS;
long idims[N];
int dim1 = atoi(argv[1]);
int dim2 = atoi(argv[2]);
assert((0 <= dim1) && (dim1 < N));
assert((0 <= dim2) && (dim2 < N));
complex float* idata = load_cfl(argv[3], N, idims);
long odims[N];
md_transpose_dims(N, dim1, dim2, odims, idims);
complex float* odata = create_cfl(argv[4], N, odims);
md_transpose(N, dim1, dim2, odims, odata, idims, idata, sizeof(complex float));
unmap_cfl(N, idims, idata);
unmap_cfl(N, odims, odata);
exit(0);
}
int main_repmat(int argc, char* argv[])
{
mini_cmdline(argc, argv, 4, usage_str, help_str);
long in_dims[DIMS];
long out_dims[DIMS];
complex float* in_data = load_cfl(argv[3], DIMS, in_dims);
int dim = atoi(argv[1]);
int rep = atoi(argv[2]);
assert(dim < DIMS);
assert(rep >= 0);
assert(1 == in_dims[dim]);
md_copy_dims(DIMS, out_dims, in_dims);
out_dims[dim] = rep;
complex float* out_data = create_cfl(argv[4], DIMS, out_dims);
long in_strs[DIMS];
long out_strs[DIMS];
md_calc_strides(DIMS, in_strs, in_dims, CFL_SIZE);
md_calc_strides(DIMS, out_strs, out_dims, CFL_SIZE);
md_copy2(DIMS, out_dims, out_strs, out_data, in_strs, in_data, CFL_SIZE);
unmap_cfl(DIMS, out_dims, out_data);
unmap_cfl(DIMS, in_dims, in_data);
exit(0);
}
int main_slice(int argc, char* argv[])
{
mini_cmdline(&argc, argv, 4, usage_str, help_str);
num_init();
long in_dims[DIMS];
long out_dims[DIMS];
complex float* in_data = load_cfl(argv[3], DIMS, in_dims);
int dim = atoi(argv[1]);
int pos = atoi(argv[2]);
assert(dim < DIMS);
assert(pos >= 0);
assert(pos < in_dims[dim]);
for (int i = 0; i < DIMS; i++)
out_dims[i] = in_dims[i];
out_dims[dim] = 1;
complex float* out_data = create_cfl(argv[4], DIMS, out_dims);
long pos2[DIMS] = { [0 ... DIMS - 1] = 0 };
pos2[dim] = pos;
md_slice(DIMS, MD_BIT(dim), pos2, in_dims, out_data, in_data, CFL_SIZE);
unmap_cfl(DIMS, out_dims, out_data);
unmap_cfl(DIMS, in_dims, in_data);
return 0;
}
int main_index(int argc, char* argv[])
{
mini_cmdline(&argc, argv, 3, usage_str, help_str);
num_init();
int N = atoi(argv[1]);
int s = atoi(argv[2]);
assert(N >= 0);
assert(s >= 0);
long dims[N + 1];
for (int i = 0; i < N; i++)
dims[i] = 1;
dims[N] = s;
complex float* x = create_cfl(argv[3], N + 1, dims);
for (int i = 0; i < s; i++)
x[i] = i;
unmap_cfl(N + 1, dims, x);
exit(0);
}
int main_version(int argc, char* argv[])
{
mini_cmdline(argc, argv, 0, usage_str, help_str);
printf("%s\n", bart_version);
exit(0);
}
int main_estdelay(int argc, char* argv[])
{
mini_cmdline(&argc, argv, 2, usage_str, help_str);
long tdims[DIMS];
const complex float* traj = load_cfl(argv[1], DIMS, tdims);
long tdims1[DIMS];
md_select_dims(DIMS, ~MD_BIT(1), tdims1, tdims);
complex float* traj1 = md_alloc(DIMS, tdims1, CFL_SIZE);
md_slice(DIMS, MD_BIT(1), (long[DIMS]){ 0 }, tdims, traj1, traj, CFL_SIZE);
int main_carg(int argc, char* argv[])
{
mini_cmdline(argc, argv, 2, usage_str, help_str);
long dims[DIMS];
complex float* in_data = load_cfl(argv[1], DIMS, dims);
complex float* out_data = create_cfl(argv[2], DIMS, dims);
md_zarg(DIMS, dims, out_data, in_data);
unmap_cfl(DIMS, dims, out_data);
unmap_cfl(DIMS, dims, in_data);
exit(0);
}
int main_conj(int argc, char* argv[])
{
mini_cmdline(argc, argv, 2, usage_str, help_str);
const int N = 16;
long dims[N];
complex float* idata = load_cfl(argv[1], N, dims);
complex float* odata = create_cfl(argv[2], N, dims);
md_zconj(N, dims, odata, idata);
unmap_cfl(N, dims, idata);
unmap_cfl(N, dims, odata);
exit(0);
}
int main_flip(int argc, char* argv[])
{
mini_cmdline(argc, argv, 3, usage_str, help_str);
int N = DIMS;
long dims[N];
complex float* idata = load_cfl(argv[2], N, dims);
complex float* odata = create_cfl(argv[3], N, dims);
unsigned long flags = atoi(argv[1]);
md_flip(N, dims, flags, odata, idata, sizeof(complex float));
unmap_cfl(N, dims, idata);
unmap_cfl(N, dims, odata);
exit(0);
}
int main_invert(int argc, char* argv[])
{
mini_cmdline(&argc, argv, 2, usage_str, help_str);
num_init();
long dims[DIMS];
complex float* idata = load_cfl(argv[1], DIMS, dims);
complex float* odata = create_cfl(argv[2], DIMS, dims);
#pragma omp parallel for
for (long i = 0; i < md_calc_size(DIMS, dims); i++)
odata[i] = idata[i] == 0 ? 0. : 1. / idata[i];
unmap_cfl(DIMS, dims, idata);
unmap_cfl(DIMS, dims, odata);
return 0;
}
int main_zeros(int argc, char* argv[])
{
mini_cmdline(argc, argv, -3, usage_str, help_str);
int N = atoi(argv[1]);
assert(N >= 0);
assert(argc == 3 + N);
long dims[N];
for (int i = 0; i < N; i++) {
dims[i] = atoi(argv[2 + i]);
assert(dims[i] >= 1);
}
complex float* x = create_cfl(argv[2 + N], N, dims);
md_clear(N, dims, x, sizeof(complex float));
unmap_cfl(N, dims, x);
exit(0);
}
int main_itsense(int argc, char* argv[])
{
mini_cmdline(argc, argv, 5, usage_str, help_str);
struct sense_data data;
data.alpha = atof(argv[1]);
complex float* kspace = load_cfl(argv[3], DIMS, data.data_dims);
data.sens = load_cfl(argv[2], DIMS, data.sens_dims);
data.pattern = load_cfl(argv[4], DIMS, data.mask_dims);
// 1 2 4 8
md_select_dims(DIMS, ~COIL_FLAG, data.imgs_dims, data.sens_dims);
assert(check_dimensions(&data));
complex float* image = create_cfl(argv[5], DIMS, data.imgs_dims);
md_calc_strides(DIMS, data.sens_strs, data.sens_dims, CFL_SIZE);
md_calc_strides(DIMS, data.imgs_strs, data.imgs_dims, CFL_SIZE);
md_calc_strides(DIMS, data.data_strs, data.data_dims, CFL_SIZE);
md_calc_strides(DIMS, data.mask_strs, data.mask_dims, CFL_SIZE);
data.tmp = md_alloc(DIMS, data.data_dims, CFL_SIZE);
num_init();
sense_reco(&data, image, kspace);
unmap_cfl(DIMS, data.imgs_dims, image);
unmap_cfl(DIMS, data.mask_dims, data.pattern);
unmap_cfl(DIMS, data.sens_dims, data.sens);
unmap_cfl(DIMS, data.data_dims, data.sens);
md_free(data.tmp);
exit(0);
}
int main_rss(int argc, char* argv[argc])
{
mini_cmdline(argc, argv, 3, usage_str, help_str);
long dims[DIMS];
complex float* data = load_cfl(argv[2], DIMS, dims);
int flags = atoi(argv[1]);
assert(0 <= flags);
long odims[DIMS];
md_select_dims(DIMS, ~flags, odims, dims);
complex float* out = create_cfl(argv[3], DIMS, odims);
md_zrss(DIMS, dims, flags, out, data);
unmap_cfl(DIMS, dims, data);
unmap_cfl(DIMS, odims, out);
exit(0);
}
int main_spow(int argc, char* argv[argc])
{
mini_cmdline(argc, argv, 3, usage_str, help_str);
complex float expo;
if (0 != parse_cfl(&expo, argv[1])) {
fprintf(stderr, "ERROR: exponent %s is not a number.\n", argv[1]);
exit(1);
}
const int N = DIMS;
long dims[N];
complex float* idata = load_cfl(argv[2], N, dims);
complex float* odata = create_cfl(argv[3], N, dims);
md_zspow(N, dims, odata, idata, expo);
unmap_cfl(N, dims, idata);
unmap_cfl(N, dims, odata);
exit(0);
}
int main_extract(int argc, char* argv[])
{
mini_cmdline(argc, argv, 5, usage_str, help_str);
num_init();
long in_dims[DIMS];
long out_dims[DIMS];
complex float* in_data = load_cfl(argv[4], DIMS, in_dims);
int dim = atoi(argv[1]);
int start = atoi(argv[2]);
int end = atoi(argv[3]);
assert((0 <= dim) && (dim < DIMS));
assert(start >= 0);
assert(start <= end);
assert(end < in_dims[dim]);
for (int i = 0; i < DIMS; i++)
out_dims[i] = in_dims[i];
out_dims[dim] = end - start + 1;
complex float* out_data = create_cfl(argv[5], DIMS, out_dims);
long pos2[DIMS] = { [0 ... DIMS - 1] = 0 };
pos2[dim] = start;
md_copy_block(DIMS, pos2, out_dims, out_data, in_dims, in_data, sizeof(complex float));
unmap_cfl(DIMS, in_dims, in_data);
unmap_cfl(DIMS, out_dims, out_data);
exit(0);
}
int main_homodyne(int argc, char* argv[])
{
mini_cmdline(argc, argv, 4, usage_str, help_str);
const int N = DIMS;
long dims[N];
complex float* idata = load_cfl(argv[3], N, dims);
complex float* data = create_cfl(argv[4], N, dims);
int pfdim = atoi(argv[1]);
float frac = atof(argv[2]);
assert((0 <= pfdim) && (pfdim < N));
assert(frac > 0.);
long strs[N];
md_calc_strides(N, strs, dims, CFL_SIZE);
struct wdata wdata;
wdata.frac = frac;
wdata.pfdim = pfdim;
md_select_dims(N, MD_BIT(pfdim), wdata.wdims, dims);
md_calc_strides(N, wdata.wstrs, wdata.wdims, CFL_SIZE);
wdata.weights = md_alloc(N, wdata.wdims, CFL_SIZE);
md_loop(N, wdata.wdims, &wdata, comp_weights);
if ((1 == dims[PHS2_DIM]) || (PHS2_DIM == pfdim)) {
homodyne(wdata, FFT_FLAGS, N, dims, strs, data, idata);
} else {
unsigned int pardim = PHS2_DIM;
ifftuc(N, dims, MD_CLEAR(FFT_FLAGS, pfdim), data, idata);
long rdims[N];
md_select_dims(N, ~MD_BIT(pardim), rdims, dims);
long rstrs[N];
md_calc_strides(N, rstrs, rdims, CFL_SIZE);
#pragma omp parallel for
for (unsigned int i = 0; i < dims[pardim]; i++) {
complex float* tmp = md_alloc(N, rdims, CFL_SIZE);
long pos[N];
md_set_dims(N, pos, 0);
pos[pardim] = i;
md_copy_block(N, pos, rdims, tmp, dims, data, CFL_SIZE);
homodyne(wdata, MD_BIT(pfdim), N, rdims, rstrs, tmp, tmp);
md_copy_block(N, pos, dims, data, rdims, tmp, CFL_SIZE);
md_free(tmp);
}
}
md_free(wdata.weights);
unmap_cfl(N, dims, idata);
unmap_cfl(N, dims, data);
exit(0);
}