static struct ufft_data* ufft_create_data(const long ksp_dims[DIMS], const long pat_dims[DIMS], const complex float* pat, unsigned int flags, bool use_gpu)
{
PTR_ALLOC(struct ufft_data, data);
SET_TYPEID(ufft_data, data);
data->flags = flags;
data->use_gpu = use_gpu;
md_copy_dims(DIMS, data->pat_dims, pat_dims);
md_copy_dims(DIMS, data->ksp_dims, ksp_dims);
md_calc_strides(DIMS, data->pat_strs, pat_dims, CFL_SIZE);
md_calc_strides(DIMS, data->ksp_strs, ksp_dims, CFL_SIZE);
#ifdef USE_CUDA
data->pat = (use_gpu ? md_alloc_gpu : md_alloc)(DIMS, data->pat_dims, CFL_SIZE);
#else
data->pat = md_alloc(DIMS, data->pat_dims, CFL_SIZE);
#endif
md_copy(DIMS, data->pat_dims, data->pat, pat, CFL_SIZE);
data->fft_op = linop_fftc_create(DIMS, ksp_dims, flags);
return PTR_PASS(data);
}
const struct linop_s* linop_zfinitediff_create(unsigned int D, const long dims[D], long diffdim, bool circular)
{
PTR_ALLOC(struct zfinitediff_data, data);
SET_TYPEID(zfinitediff_data, data);
data->D = D;
data->dim_diff = diffdim;
data->do_circdiff = circular;
data->dims_in = *TYPE_ALLOC(long[D]);
data->dims_adj = *TYPE_ALLOC(long[D]);
data->strides_in = *TYPE_ALLOC(long[D]);
data->strides_adj = *TYPE_ALLOC(long[D]);
md_copy_dims(D, data->dims_in, dims);
md_copy_dims(D, data->dims_adj, dims);
md_calc_strides(D, data->strides_in, data->dims_in, CFL_SIZE);
if (!data->do_circdiff)
data->dims_adj[data->dim_diff] -= 1;
md_calc_strides(D, data->strides_adj, data->dims_adj, CFL_SIZE);
const long* dims_adj = data->dims_adj;
const long* dims_in = data->dims_in;
return linop_create(D, dims_adj, D, dims_in, CAST_UP(PTR_PASS(data)),
zfinitediff_apply, zfinitediff_adjoint,
zfinitediff_normal, NULL, zfinitediff_del);
}
void fwtN(unsigned int N, unsigned int flags, const long shifts[N], const long dims[N], const long ostr[2 * N], complex float* out, const long istr[N], const complex float* in, const long flen, const float filter[2][2][flen])
{
long odims[2 * N];
wavelet_dims(N, flags, odims, dims, flen);
assert(md_calc_size(2 * N, odims) >= md_calc_size(N, dims));
// FIXME one of these is unnecessary if we use the output
complex float* tmpA = md_alloc_sameplace(2 * N, odims, CFL_SIZE, out);
complex float* tmpB = md_alloc_sameplace(2 * N, odims, CFL_SIZE, out);
long tidims[2 * N];
md_copy_dims(N, tidims, dims);
md_singleton_dims(N, tidims + N);
long tistrs[2 * N];
md_calc_strides(2 * N, tistrs, tidims, CFL_SIZE);
long todims[2 * N];
md_copy_dims(2 * N, todims, tidims);
long tostrs[2 * N];
// maybe we should push the randshift into lower levels
//md_copy2(N, dims, tistrs, tmpA, istr, in, CFL_SIZE);
md_circ_shift2(N, dims, shifts, tistrs, tmpA, istr, in, CFL_SIZE);
for (unsigned int i = 0; i < N; i++) {
if (MD_IS_SET(flags, i)) {
todims[0 + i] = odims[0 + i];
todims[N + i] = odims[N + i];
md_calc_strides(2 * N, tostrs, todims, CFL_SIZE);
fwt1(2 * N, i, tidims, tostrs, tmpB, (void*)tmpB + tostrs[N + i], tistrs, tmpA, flen, filter);
md_copy_dims(2 * N, tidims, todims);
md_copy_dims(2 * N, tistrs, tostrs);
complex float* swap = tmpA;
tmpA = tmpB;
tmpB = swap;
}
}
md_copy2(2 * N, todims, ostr, out, tostrs, tmpA, CFL_SIZE);
md_free(tmpA);
md_free(tmpB);
}
void iwtN(unsigned int N, unsigned int flags, const long shifts[N], const long dims[N], const long ostr[N], complex float* out, const long istr[2 * N], const complex float* in, const long flen, const float filter[2][2][flen])
{
long idims[2 * N];
wavelet_dims(N, flags, idims, dims, flen);
assert(md_calc_size(2 * N, idims) >= md_calc_size(N, dims));
complex float* tmpA = md_alloc_sameplace(2 * N, idims, CFL_SIZE, out);
complex float* tmpB = md_alloc_sameplace(2 * N, idims, CFL_SIZE, out);
long tidims[2 * N];
md_copy_dims(2 * N, tidims, idims);
long tistrs[2 * N];
md_calc_strides(2 * N, tistrs, tidims, CFL_SIZE);
long todims[2 * N];
md_copy_dims(2 * N, todims, tidims);
long tostrs[2 * N];
long ishifts[N];
for (unsigned int i = 0; i < N; i++)
ishifts[i] = -shifts[i];
md_copy2(2 * N, tidims, tistrs, tmpA, istr, in, CFL_SIZE);
for (int i = N - 1; i >= 0; i--) { // run backwards to maintain contigous blocks
if (MD_IS_SET(flags, i)) {
todims[0 + i] = dims[0 + i];
todims[N + i] = 1;
md_calc_strides(2 * N, tostrs, todims, CFL_SIZE);
iwt1(2 * N, i, todims, tostrs, tmpB, tistrs, tmpA, (void*)tmpA + tistrs[N + i], flen, filter);
md_copy_dims(2 * N, tidims, todims);
md_copy_dims(2 * N, tistrs, tostrs);
complex float* swap = tmpA;
tmpA = tmpB;
tmpB = swap;
}
}
//md_copy2(N, dims, ostr, out, tostrs, tmpA, CFL_SIZE);
md_circ_shift2(N, dims, ishifts, ostr, out, tostrs, tmpA, CFL_SIZE);
md_free(tmpA);
md_free(tmpB);
}
/**
* Create a resize linear operator: y = M x,
* where M either crops or expands the the input dimensions to match the output dimensions.
* Uses centered zero-padding and centered cropping
*
* @param N number of dimensions
* @param out_dims output dimensions
* @param in_dims input dimensions
*/
struct linop_s* linop_resize_create(unsigned int N, const long out_dims[N], const long in_dims[N])
{
struct resize_op_s* data = xmalloc(sizeof(struct resize_op_s));
data->N = N;
data->out_dims = xmalloc(N * sizeof(long));
data->in_dims = xmalloc(N * sizeof(long));
md_copy_dims(N, (long*)data->out_dims, out_dims);
md_copy_dims(N, (long*)data->in_dims, in_dims);
return linop_create(N, out_dims, N, in_dims, data, resize_forward, resize_adjoint, resize_normal, NULL, resize_free);
}
/**
* Create a resize linear operator: y = M x,
* where M either crops or expands the the input dimensions to match the output dimensions.
* Uses centered zero-padding and centered cropping
*
* @param N number of dimensions
* @param out_dims output dimensions
* @param in_dims input dimensions
*/
struct linop_s* linop_resize_create(unsigned int N, const long out_dims[N], const long in_dims[N])
{
PTR_ALLOC(struct resize_op_s, data);
SET_TYPEID(resize_op_s, data);
data->N = N;
data->out_dims = *TYPE_ALLOC(long[N]);
data->in_dims = *TYPE_ALLOC(long[N]);
md_copy_dims(N, (long*)data->out_dims, out_dims);
md_copy_dims(N, (long*)data->in_dims, in_dims);
return linop_create(N, out_dims, N, in_dims, CAST_UP(PTR_PASS(data)), resize_forward, resize_adjoint, resize_normal, NULL, resize_free);
}
const struct operator_s* fft_create2(unsigned int D, const long dimensions[D], unsigned long flags, const long ostrides[D], complex float* dst, const long istrides[D], const complex float* src, bool backwards)
{
PTR_ALLOC(struct fft_plan_s, plan);
SET_TYPEID(fft_plan_s, plan);
plan->fftw = fft_fftwf_plan(D, dimensions, flags, ostrides, dst, istrides, src, backwards, false);
#ifdef USE_CUDA
plan->cuplan = NULL;
#ifndef LAZY_CUDA
if (cuda_ondevice(src))
plan->cuplan = fft_cuda_plan(D, dimensions, flags, ostrides, istrides, backwards);
#else
plan->D = D;
plan->flags = flags;
plan->backwards = backwards;
PTR_ALLOC(long[D], dims);
md_copy_dims(D, *dims, dimensions);
plan->dims = *PTR_PASS(dims);
PTR_ALLOC(long[D], istrs);
md_copy_strides(D, *istrs, istrides);
plan->istrs = *PTR_PASS(istrs);
PTR_ALLOC(long[D], ostrs);
md_copy_strides(D, *ostrs, ostrides);
plan->ostrs = *PTR_PASS(ostrs);
#endif
#endif
return operator_create2(D, dimensions, ostrides, D, dimensions, istrides, CAST_UP(PTR_PASS(plan)), fft_apply, fft_free_plan);
}
const struct operator_s* nufft_precond_create(const struct linop_s* nufft_op)
{
const auto data = CAST_DOWN(nufft_data, linop_get_data(nufft_op));
PTR_ALLOC(struct nufft_precond_data, pdata);
SET_TYPEID(nufft_precond_data, pdata);
assert(data->conf.toeplitz);
int N = data->N;
int ND = N + 1;
pdata->N = N;
pdata->cim_dims = *TYPE_ALLOC(long[ND]);
pdata->pre_dims = *TYPE_ALLOC(long[ND]);
pdata->cim_strs = *TYPE_ALLOC(long[ND]);
pdata->pre_strs = *TYPE_ALLOC(long[ND]);
md_copy_dims(ND, pdata->cim_dims, data->cim_dims);
md_select_dims(ND, data->flags, pdata->pre_dims, pdata->cim_dims);
md_calc_strides(ND, pdata->cim_strs, pdata->cim_dims, CFL_SIZE);
md_calc_strides(ND, pdata->pre_strs, pdata->pre_dims, CFL_SIZE);
pdata->pre = compute_precond(pdata->N, pdata->pre_dims, pdata->pre_strs, data->psf_dims, data->psf_strs, data->psf, data->linphase);
pdata->fft_op = linop_fft_create(pdata->N, pdata->cim_dims, data->flags);
const long* cim_dims = pdata->cim_dims; // need to dereference pdata before PTR_PASS
return operator_create(N, cim_dims, N, cim_dims, CAST_UP(PTR_PASS(pdata)), nufft_precond_apply, nufft_precond_del);
}
struct prox_dfwavelet_data* prepare_prox_dfwavelet_data(const long im_dims[DIMS], const long min_size[3], const complex float res[3], unsigned int flow_dim, float lambda, bool use_gpu)
{
// get dimension
PTR_ALLOC(struct prox_dfwavelet_data, data);
md_copy_dims(DIMS, data->im_dims, im_dims);
md_select_dims(DIMS, FFT_FLAGS, data->tim_dims, im_dims);
md_calc_strides(DIMS, data->im_strs, im_dims, CFL_SIZE);
// initialize temp
#ifdef USE_CUDA
if (use_gpu) {
data->vx = md_alloc_gpu(DIMS, data->tim_dims, CFL_SIZE);
data->vy = md_alloc_gpu(DIMS, data->tim_dims, CFL_SIZE);
data->vz = md_alloc_gpu(DIMS, data->tim_dims, CFL_SIZE);
} else
#endif
{
data->vx = md_alloc(DIMS, data->tim_dims, CFL_SIZE);
data->vy = md_alloc(DIMS, data->tim_dims, CFL_SIZE);
data->vz = md_alloc(DIMS, data->tim_dims, CFL_SIZE);
}
data->flow_dim = flow_dim;
data->slice_flag = ~FFT_FLAGS;
data->lambda = lambda;
data->plan = prepare_dfwavelet_plan(3, data->tim_dims, (long*) min_size, (complex float*) res, use_gpu);
return data;
}
/**
* Thresholding operator for l0-norm: f(x) = || x ||_0 <= k, as used in NIHT algorithm.
* y = HT(x, k) (hard thresholding, ie keeping the k largest elements).
*
* @param D number of dimensions
* @param dim dimensions of x
* @param k threshold parameter (non-zero elements to keep)
* @param flags bitmask for joint thresholding
*/
const struct operator_p_s* prox_niht_thresh_create(unsigned int D, const long dim[D], const unsigned int k, const unsigned long flags)
{
PTR_ALLOC(struct thresh_s, data);
SET_TYPEID(thresh_s, data);
data->lambda = 0.;
data->k = k;
data->D = D;
data->flags = flags;
data->unitary_op = NULL;
PTR_ALLOC(long[D], ndim);
md_copy_dims(D, *ndim, dim);
data->dim = *PTR_PASS(ndim);
// norm dimensions are the flagged input dimensions
PTR_ALLOC(long[D], norm_dim);
md_select_dims(D, ~flags, *norm_dim, data->dim);
data->norm_dim = *PTR_PASS(norm_dim);
PTR_ALLOC(long[D], nstr);
md_calc_strides(D, *nstr, data->dim, CFL_SIZE);
data->str = *PTR_PASS(nstr);
return operator_p_create(D, dim, D, dim, CAST_UP(PTR_PASS(data)), hardthresh_apply, thresh_del);
}
static struct maps_data* maps_create_data(const long max_dims[DIMS],
unsigned int sens_flags, const complex float* sens, bool gpu)
{
struct maps_data* data = xmalloc(sizeof(struct maps_data));
// maximal dimensions
md_copy_dims(DIMS, data->max_dims, max_dims);
// sensitivity dimensions
md_select_dims(DIMS, sens_flags, data->mps_dims, max_dims);
md_calc_strides(DIMS, data->strs_mps, data->mps_dims, CFL_SIZE);
md_select_dims(DIMS, ~MAPS_FLAG, data->ksp_dims, max_dims);
md_calc_strides(DIMS, data->strs_ksp, data->ksp_dims, CFL_SIZE);
md_select_dims(DIMS, ~COIL_FLAG, data->img_dims, max_dims);
md_calc_strides(DIMS, data->strs_img, data->img_dims, CFL_SIZE);
#ifdef USE_CUDA
complex float* nsens = (gpu ? md_alloc_gpu : md_alloc)(DIMS, data->mps_dims, CFL_SIZE);
#else
assert(!gpu);
complex float* nsens = md_alloc(DIMS, data->mps_dims, CFL_SIZE);
#endif
md_copy(DIMS, data->mps_dims, nsens, sens, CFL_SIZE);
data->sens = nsens;
data->norm = NULL;
return data;
}
static struct linop_s* linop_gdiag_create(unsigned int N, const long dims[N], unsigned int flags, const complex float* diag, bool rdiag)
{
PTR_ALLOC(struct cdiag_s, data);
SET_TYPEID(cdiag_s, data);
data->rmul = rdiag;
data->N = N;
PTR_ALLOC(long[N], dims2);
PTR_ALLOC(long[N], dstrs);
PTR_ALLOC(long[N], strs);
long ddims[N];
md_select_dims(N, flags, ddims, dims);
md_copy_dims(N, *dims2, dims);
md_calc_strides(N, *strs, dims, CFL_SIZE);
md_calc_strides(N, *dstrs, ddims, CFL_SIZE);
data->dims = *PTR_PASS(dims2);
data->strs = *PTR_PASS(strs);
data->dstrs = *PTR_PASS(dstrs);
data->diag = diag; // make a copy?
#ifdef USE_CUDA
data->gpu_diag = NULL;
#endif
return linop_create(N, dims, N, dims, CAST_UP(PTR_PASS(data)), cdiag_apply, cdiag_adjoint, cdiag_normal, NULL, cdiag_free);
}
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);
}
void wavelet_dims(unsigned int N, unsigned int flags, long odims[2 * N], const long dims[N], const long flen)
{
md_copy_dims(N, odims, dims);
md_singleton_dims(N, odims + N);
wavelet_dims_r(N, N - 1, flags, odims, dims, flen);
}
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);
}
/**
* Intialize lrthresh data
*
* @param dims_decom - dimensions with levels at LEVEL_DIMS
* @param randshift - randshift boolean
* @param mflags - selects which dimensions gets reshaped as the first dimension in matrix
* @param blkdims - contains block dimensions for all levels
*
*/
static struct lrthresh_data_s* lrthresh_create_data(const long dims_decom[DIMS], bool randshift, unsigned long mflags, const long blkdims[MAX_LEV][DIMS], float lambda, bool noise, int remove_mean)
{
PTR_ALLOC(struct lrthresh_data_s, data);
SET_TYPEID(lrthresh_data_s, data);
data->randshift = randshift;
data->mflags = mflags;
data->lambda = lambda;
data->noise = noise;
data->remove_mean = remove_mean;
// level dimensions
md_copy_dims(DIMS, data->dims_decom, dims_decom);
md_calc_strides(DIMS, data->strs_lev, dims_decom, CFL_SIZE);
// image dimensions
data->levels = dims_decom[LEVEL_DIM];
md_select_dims(DIMS, ~LEVEL_FLAG, data->dims, dims_decom);
md_calc_strides(DIMS, data->strs, data->dims, CFL_SIZE);
// blkdims
for(long l = 0; l < data->levels; l++) {
for (long i = 0; i < DIMS; i++)
data->blkdims[l][i] = blkdims[l][i];
}
return PTR_PASS(data);
}
/**
* Proximal operator for l1-norm with unitary transform: f(x) = lambda || T x ||_1
*
* @param D number of dimensions
* @param dim dimensions of x
* @param lambda threshold parameter
* @param unitary_op unitary linear operator
* @param flags bitmask for joint soft-thresholding
*/
extern const struct operator_p_s* prox_unithresh_create(unsigned int D, const struct linop_s* unitary_op, const float lambda, const unsigned long flags)
{
PTR_ALLOC(struct thresh_s, data);
SET_TYPEID(thresh_s, data);
data->lambda = lambda;
data->D = D;
data->flags = flags;
data->unitary_op = unitary_op;
const long* dims = linop_domain(unitary_op)->dims;
PTR_ALLOC(long[D], ndim);
md_copy_dims(D, *ndim, dims);
data->dim = *PTR_PASS(ndim);
PTR_ALLOC(long[D], nstr);
md_calc_strides(D, *nstr, data->dim, CFL_SIZE);
data->str = *PTR_PASS(nstr);
// norm dimensions are the flagged transform dimensions
// FIXME should use linop_codomain(unitary_op)->N
PTR_ALLOC(long[D], norm_dim);
md_select_dims(D, ~flags, *norm_dim, linop_codomain(unitary_op)->dims);
data->norm_dim = *PTR_PASS(norm_dim);
return operator_p_create(D, dims, D, dims, CAST_UP(PTR_PASS(data)), unisoftthresh_apply, thresh_del);
}
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 linop_s* linop_fmac_create(unsigned int N, const long dims[N],
unsigned int oflags, unsigned int iflags, unsigned int tflags, const complex float* tensor)
{
PTR_ALLOC(struct fmac_data, data);
SET_TYPEID(fmac_data, data);
data->N = N;
data->dims = *TYPE_ALLOC(long[N]);
md_copy_dims(N, data->dims, dims);
data->idims = *TYPE_ALLOC(long[N]);
data->istrs = *TYPE_ALLOC(long[N]);
md_select_dims(N, ~iflags, data->idims, dims);
md_calc_strides(N, data->istrs, data->idims, CFL_SIZE);
data->odims = *TYPE_ALLOC(long[N]);
data->ostrs = *TYPE_ALLOC(long[N]);
md_select_dims(N, ~oflags, data->odims, dims);
md_calc_strides(N, data->ostrs, data->odims, CFL_SIZE);
data->tstrs = *TYPE_ALLOC(long[N]);
data->tdims = *TYPE_ALLOC(long[N]);
md_select_dims(N, ~tflags, data->tdims, dims);
md_calc_strides(N, data->tstrs, data->tdims, CFL_SIZE);
data->tensor = tensor;
#ifdef USE_CUDA
data->gpu_tensor = NULL;
#endif
long odims[N];
md_copy_dims(N, odims, data->odims);
long idims[N];
md_copy_dims(N, idims, data->idims);
return linop_create(N, odims, N, idims,
CAST_UP(PTR_PASS(data)), fmac_apply, fmac_adjoint, NULL,
NULL, fmac_free_data);
}
int main_copy(int argc, char* argv[])
{
const struct opt_s opts[] = { };
cmdline(&argc, argv, 2, 1000, usage_str, help_str, ARRAY_SIZE(opts), opts);
num_init();
unsigned int N = DIMS;
int count = argc - 3;
assert((count >= 0) && (count % 2 == 0));
long in_dims[N];
long out_dims[N];
void* in_data = load_cfl(argv[argc - 2], N, in_dims);
if (count > 0) {
// get dimensions
void* out_data = load_cfl(argv[argc - 1], N, out_dims);
unmap_cfl(N, out_dims, out_data);
} else {
md_copy_dims(N, out_dims, in_dims);
}
void* out_data = create_cfl(argv[argc - 1], N, out_dims);
long position[N];
for (unsigned int i = 0; i < N; i++)
position[i] = 0;
for (int i = 0; i < count; i += 2) {
unsigned int dim = atoi(argv[i + 1]);
long pos = atol(argv[i + 2]);
assert(dim < N);
assert((0 <= pos) && (pos < out_dims[dim]));
position[dim] = pos;
}
md_copy_block(N, position, out_dims, out_data, in_dims, in_data, CFL_SIZE);
unmap_cfl(N, in_dims, in_data);
unmap_cfl(N, out_dims, out_data);
return 0;
}
void fwt1(unsigned int N, unsigned int d, const long dims[N], const long ostr[N], complex float* low, complex float* hgh, const long istr[N], const complex float* in, const long flen, const float filter[2][2][flen])
{
debug_printf(DP_DEBUG4, "fwt1: %d/%d\n", d, N);
debug_print_dims(DP_DEBUG4, N, dims);
assert(dims[d] >= 2);
long odims[N];
md_copy_dims(N, odims, dims);
odims[d] = bandsize(dims[d], flen);
debug_print_dims(DP_DEBUG4, N, odims);
long o = d + 1;
long u = N - o;
// 0 1 2 3 4 5 6|7
// --d-- * --u--|N
// ---o---
assert(d == md_calc_blockdim(d, dims + 0, istr + 0, CFL_SIZE));
assert(u == md_calc_blockdim(u, dims + o, istr + o, CFL_SIZE * md_calc_size(o, dims)));
assert(d == md_calc_blockdim(d, odims + 0, ostr + 0, CFL_SIZE));
assert(u == md_calc_blockdim(u, odims + o, ostr + o, CFL_SIZE * md_calc_size(o, odims)));
// merge dims
long wdims[3] = { md_calc_size(d, dims), dims[d], md_calc_size(u, dims + o) };
long wistr[3] = { CFL_SIZE, istr[d], CFL_SIZE * md_calc_size(o, dims) };
long wostr[3] = { CFL_SIZE, ostr[d], CFL_SIZE * md_calc_size(o, odims) };
#ifdef USE_CUDA
if (cuda_ondevice(in)) {
assert(cuda_ondevice(low));
assert(cuda_ondevice(hgh));
float* flow = md_gpu_move(1, MD_DIMS(flen), filter[0][0], FL_SIZE);
float* fhgh = md_gpu_move(1, MD_DIMS(flen), filter[0][1], FL_SIZE);
wl3_cuda_down3(wdims, wostr, low, wistr, in, flen, flow);
wl3_cuda_down3(wdims, wostr, hgh, wistr, in, flen, fhgh);
md_free(flow);
md_free(fhgh);
return;
}
#endif
// no clear needed
wavelet_down3(wdims, wostr, low, wistr, in, flen, filter[0][0]);
wavelet_down3(wdims, wostr, hgh, wistr, in, flen, filter[0][1]);
}
struct view_s* create_view(const char* name, long* pos, const long dims[DIMS], const complex float* data)
{
long sq_dims[2] = { 0 };
int l = 0;
for (int i = 0; (i < DIMS) && (l < 2); i++)
if (1 != dims[i])
sq_dims[l++] = i;
assert(2 == l);
struct view_s* v = xmalloc(sizeof(struct view_s));
v->next = v->prev = v;
v->sync = true;
v->name = name;
v->pos = pos;
v->max = 1.;
if (NULL == v->pos)
v->pos = xmalloc(DIMS * sizeof(long));
v->xdim = sq_dims[0];
v->ydim = sq_dims[1];
v->xzoom = 2.;
v->yzoom = 2.;
v->source = NULL;
v->rgb = NULL;
v->buf = NULL;
md_copy_dims(DIMS, v->dims, dims);
md_calc_strides(DIMS, v->strs, dims, sizeof(complex float));
v->data = data;
for (int i = 0; i < DIMS; i++)
v->pos[i] = 0;
v->winlow = 0.;
v->winhigh = 1.;
v->phrot = 0.;
v->lastx = -1;
v->lasty = -1;
v->invalid = true;
return v;
}
struct linop_s* rvc_create(unsigned int N, const long dims[N])
{
PTR_ALLOC(struct rvc_s, data);
PTR_ALLOC(long[N], dims2);
md_copy_dims(N, *dims2, dims);
data->N = N;
data->dims = *dims2;
return linop_create(N, dims, N, dims, (void*)data, rvc_apply, rvc_apply, rvc_apply, NULL, rvc_free);
}
void iwt1(unsigned int N, unsigned int d, const long dims[N], const long ostr[N], complex float* out, const long istr[N], const complex float* low, const complex float* hgh, const long flen, const float filter[2][2][flen])
{
debug_printf(DP_DEBUG4, "ifwt1: %d/%d\n", d, N);
debug_print_dims(DP_DEBUG4, N, dims);
assert(dims[d] >= 2);
long idims[N];
md_copy_dims(N, idims, dims);
idims[d] = bandsize(dims[d], flen);
debug_print_dims(DP_DEBUG4, N, idims);
long o = d + 1;
long u = N - o;
// 0 1 2 3 4 5 6|7
// --d-- * --u--|N
// ---o---
assert(d == md_calc_blockdim(d, dims + 0, ostr + 0, CFL_SIZE));
assert(u == md_calc_blockdim(u, dims + o, ostr + o, CFL_SIZE * md_calc_size(o, dims)));
assert(d == md_calc_blockdim(d, idims + 0, istr + 0, CFL_SIZE));
assert(u == md_calc_blockdim(u, idims + o, istr + o, CFL_SIZE * md_calc_size(o, idims)));
long wdims[3] = { md_calc_size(d, dims), dims[d], md_calc_size(u, dims + o) };
long wistr[3] = { CFL_SIZE, istr[d], CFL_SIZE * md_calc_size(o, idims) };
long wostr[3] = { CFL_SIZE, ostr[d], CFL_SIZE * md_calc_size(o, dims) };
md_clear(3, wdims, out, CFL_SIZE); // we cannot clear because we merge outputs
#ifdef USE_CUDA
if (cuda_ondevice(out)) {
assert(cuda_ondevice(low));
assert(cuda_ondevice(hgh));
float* flow = md_gpu_move(1, MD_DIMS(flen), filter[1][0], FL_SIZE);
float* fhgh = md_gpu_move(1, MD_DIMS(flen), filter[1][1], FL_SIZE);
wl3_cuda_up3(wdims, wostr, out, wistr, low, flen, flow);
wl3_cuda_up3(wdims, wostr, out, wistr, hgh, flen, fhgh);
md_free(flow);
md_free(fhgh);
return;
}
#endif
wavelet_up3(wdims, wostr, out, wistr, low, flen, filter[1][0]);
wavelet_up3(wdims, wostr, out, wistr, hgh, flen, filter[1][1]);
}
/**
* Proximal operator for l1-norm with Wavelet transform: f(x) = lambda || W x ||_1
*
* @param N number of dimensions
* @param dims dimensions of x
* @param flags bitmask for Wavelet transform
* @param minsize minimium size of coarse Wavelet scale
* @param lambda threshold parameter
* @param randshift random shifting
*/
const struct operator_p_s* prox_wavelet3_thresh_create(unsigned int N, const long dims[N], unsigned int flags, const long minsize[N], float lambda, bool randshift)
{
PTR_ALLOC(struct wavelet3_thresh_s, data);
SET_TYPEID(wavelet3_thresh_s, data);
data->N = N;
long (*ndims)[N] = TYPE_ALLOC(long[N]);
md_copy_dims(N, (*ndims), dims);
data->dims = *ndims;
long (*nminsize)[N] = TYPE_ALLOC(long[N]);
md_copy_dims(N, (*nminsize), minsize);
data->minsize = *nminsize;
data->flags = flags;
data->lambda = lambda;
data->randshift = randshift;
data->rand_state = 1;
return operator_p_create(N, dims, N, dims, CAST_UP(PTR_PASS(data)), wavelet3_thresh_apply, wavelet3_thresh_del);
}
struct linop_s* tv_init(long N, const long dims[N], unsigned int flags)
{
struct tv_s* data = xmalloc(sizeof(struct tv_s));
data->N = N + 1;
data->dims = xmalloc((N + 1) * sizeof(long));
data->flags = flags;
md_copy_dims(N, data->dims, dims);
data->dims[N] = bitcount(flags);
return linop_create(N + 1, data->dims, N, dims, data, tv_op_apply, tv_op_adjoint, tv_op_normal, NULL, tv_op_free);
}
struct linop_s* linop_realval_create(unsigned int N, const long dims[N])
{
PTR_ALLOC(struct rvc_s, data);
SET_TYPEID(rvc_s, data);
PTR_ALLOC(long[N], dims2);
md_copy_dims(N, *dims2, dims);
data->N = N;
data->dims = *PTR_PASS(dims2);
return linop_create(N, dims, N, dims, CAST_UP(PTR_PASS(data)), rvc_apply, rvc_apply, rvc_apply, NULL, rvc_free);
}
static void linop_matrix_apply_normal(const linop_data_t* _data, complex float* dst, const complex float* src)
{
const struct operator_matrix_s* data = CAST_DOWN(operator_matrix_s, _data);
unsigned int N = data->mat_iovec->N;
// FIXME check all the cases where computation can be done with blas
//debug_printf(DP_DEBUG1, "compute normal\n");
if (cgemm_forward_standard(data)) {
long max_dims_gram[N];
md_copy_dims(N, max_dims_gram, data->domain_iovec->dims);
max_dims_gram[data->T_dim] = data->K;
long tmp_dims[N];
long tmp_str[N];
md_copy_dims(N, tmp_dims, max_dims_gram);
tmp_dims[data->K_dim] = 1;
md_calc_strides(N, tmp_str, tmp_dims, CFL_SIZE);
complex float* tmp = md_alloc_sameplace(N, data->domain_iovec->dims, CFL_SIZE, dst);
md_clear(N, data->domain_iovec->dims, tmp, CFL_SIZE);
md_zfmac2(N, max_dims_gram, tmp_str, tmp, data->domain_iovec->strs, src, data->mat_gram_iovec->strs, data->mat_gram);
md_transpose(N, data->T_dim, data->K_dim, data->domain_iovec->dims, dst, tmp_dims, tmp, CFL_SIZE);
md_free(tmp);
} else {
long L = md_calc_size(data->T_dim, data->domain_iovec->dims);
blas_cgemm('N', 'T', L, data->K, data->K, 1.,
L, (const complex float (*)[])src,
data->K, (const complex float (*)[])data->mat_gram,
0., L, (complex float (*)[])dst);
}
}
static complex float* compute_psf2(unsigned int N, const long psf_dims[N + 3], const long trj_dims[N + 3], const complex float* traj, const complex float* weights)
{
unsigned int ND = N + 3;
long img_dims[ND];
long img_strs[ND];
md_select_dims(ND, ~MD_BIT(N + 0), img_dims, psf_dims);
md_calc_strides(ND, img_strs, img_dims, CFL_SIZE);
// PSF 2x size
long img2_dims[ND];
long img2_strs[ND];
md_copy_dims(ND, img2_dims, img_dims);
for (int i = 0; i < 3; i++)
img2_dims[i] = (1 == img_dims[i]) ? 1 : (2 * img_dims[i]);
md_calc_strides(ND, img2_strs, img2_dims, CFL_SIZE);
complex float* traj2 = md_alloc(ND, trj_dims, CFL_SIZE);
md_zsmul(ND, trj_dims, traj2, traj, 2.);
complex float* psft = compute_psf(ND, img2_dims, trj_dims, traj2, weights);
md_free(traj2);
fftuc(ND, img2_dims, FFT_FLAGS, psft, psft);
// reformat
long sub2_strs[ND];
md_copy_strides(ND, sub2_strs, img2_strs);
for(int i = 0; i < 3; i++)
sub2_strs[i] *= 2;;
complex float* psf = md_alloc(ND, psf_dims, CFL_SIZE);
long factors[N];
for (unsigned int i = 0; i < N; i++)
factors[i] = ((img_dims[i] > 1) && (i < 3)) ? 2 : 1;
md_decompose(N + 0, factors, psf_dims, psf, img2_dims, psft, CFL_SIZE);
md_free(psft);
return psf;
}
/**
* Wavelet CFD9/7 transform operator
*
* @param N number of dimensions
* @param dims dimensions of input
* @param flags bitmask of the dimensions to apply the Fourier transform
*/
struct linop_s* linop_cdf97_create(int N, const long dims[N], unsigned int flags)
{
PTR_ALLOC(struct linop_cdf97_s, data);
SET_TYPEID(linop_cdf97_s, data);
PTR_ALLOC(long[N], ndims);
md_copy_dims(N, *ndims, dims);
data->N = N;
data->dims = *ndims;
data->flags = flags;
return linop_create(N, dims, N, dims, CAST_UP(PTR_PASS(data)), linop_cdf97_apply, linop_cdf97_adjoint, linop_cdf97_normal, NULL, linop_cdf97_free);
}
