int main_estdelay(int argc, char* argv[])
{
bool ring = false;
int pad_factor = 100;
unsigned int no_intersec_sp = 1;
float size = 1.5;
const struct opt_s opts[] = {
OPT_SET('R', &ring, "RING method"),
OPT_INT('p', &pad_factor, "p", "[RING] Padding"),
OPT_UINT('n', &no_intersec_sp, "n", "[RING] Number of intersecting spokes"),
OPT_FLOAT('r', &size, "r", "[RING] Central region size"),
};
cmdline(&argc, argv, 2, 2, usage_str, help_str, ARRAY_SIZE(opts), opts);
num_init();
if (pad_factor % 2 != 0)
error("Pad_factor -p should be even\n");
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_threshold(int argc, char* argv[])
{
unsigned int flags = 0;
enum th_type { NONE, WAV, LLR, DFW, MPDFW, HARD } th_type = NONE;
int llrblk = 8;
const struct opt_s opts[] = {
OPT_SELECT('H', enum th_type, &th_type, HARD, "hard thresholding"),
OPT_SELECT('W', enum th_type, &th_type, WAV, "daubechies wavelet soft-thresholding"),
OPT_SELECT('L', enum th_type, &th_type, LLR, "locally low rank soft-thresholding"),
OPT_SELECT('D', enum th_type, &th_type, DFW, "divergence-free wavelet soft-thresholding"),
OPT_UINT('j', &flags, "bitmask", "joint soft-thresholding"),
OPT_INT('b', &llrblk, "blocksize", "locally low rank block size"),
};
cmdline(&argc, argv, 3, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
num_init();
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);
float lambda = atof(argv[1]);
switch (th_type) {
case WAV:
wthresh(N, dims, lambda, flags, odata, idata);
break;
case LLR:
lrthresh(N, dims, llrblk, lambda, flags, odata, idata);
break;
case DFW:
dfthresh(N, dims, lambda, odata, idata);
break;
case HARD:
hard_thresh(N, dims, lambda, odata, idata);
break;
default:
md_zsoftthresh(N, dims, lambda, flags, odata, idata);
}
unmap_cfl(N, dims, idata);
unmap_cfl(N, dims, odata);
return 0;
}
static int
qopqdp_dw(lua_State *L)
{
BEGIN_ARGS;
GET_LATTICE(lat);
OPT_INT(nc, lat->defaultNc);
END_ARGS;
qopqdp_dw_create(L, nc, lat);
return 1;
}
static int
qopqdp_gauge(lua_State *L)
{
BEGIN_ARGS;
GET_LATTICE(lat);
OPT_STRING(precision, lat->defaultPrecision);
OPT_INT(nc, lat->defaultNc);
END_ARGS;
if(*precision=='F') {
qopqdp_gaugeF_create(L, nc, lat);
} else {
qopqdp_gaugeD_create(L, nc, lat);
}
return 1;
}
static int
qopqdp_defaultNc(lua_State *L)
{
BEGIN_ARGS;
OPT_INT(nc, 0);
END_ARGS;
if(nc>0) {
#if QOP_Colors != 'N'
qlassert(L, nc==QOP_Colors);
#endif
defaultNc = nc;
return 0;
}
lua_pushinteger(L, defaultNc);
return 1;
}
static int
qopqdp_lattice_seed(lua_State *L)
{
BEGIN_ARGS;
GET_LATTICE(l);
GET_INT(seed);
OPT_INT(uniform, -1);
OPT_SUBSET(sub, l, QDP_all_L(l->qlat));
END_ARGS;
if(l->rs==NULL) {
qopqdp_rstate_t *r = qopqdp_rstate_create(L, l);
l->rs = r->field;
QHMC_USERTABLE_SETFIELD(L, 1, "rs");
}
qhmc_qopqdp_seed_func(l->rs, seed, uniform, sub);
return 0;
}
static int
qopqdp_lattice_call(lua_State *L)
{
BEGIN_ARGS;
GET_LATTICE(l);
OPT_INT(dim, 0);
END_ARGS;
if(dim>0) {
int s = QDP_coord_size_L(l->qlat, dim-1);
lua_pushinteger(L, s);
} else {
int nd = QDP_ndim_L(l->qlat);
int x[nd];
QDP_latsize_L(l->qlat, x);
qhmc_push_int_array(L, nd, x);
}
return 1;
}
static void modeset_destroy_fb(int fd, struct modeset_buf *buf)
{
if (buf->map) {
munmap(buf->map, buf->size);
}
if (buf->fb) {
drmModeRmFB(fd, buf->fb);
}
if (buf->handle) {
struct drm_mode_destroy_dumb dreq = {
.handle = buf->handle,
};
drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);
}
}
static int modeset_create_fb(struct vo *vo, int fd, struct modeset_buf *buf)
{
int ret = 0;
buf->handle = 0;
// create dumb buffer
struct drm_mode_create_dumb creq = {
.width = buf->width,
.height = buf->height,
.bpp = 32,
};
ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq);
if (ret < 0) {
MP_ERR(vo, "Cannot create dumb buffer: %s\n", mp_strerror(errno));
ret = -errno;
goto end;
}
buf->stride = creq.pitch;
buf->size = creq.size;
buf->handle = creq.handle;
// create framebuffer object for the dumb-buffer
ret = drmModeAddFB(fd, buf->width, buf->height, 24, 32, buf->stride,
buf->handle, &buf->fb);
if (ret) {
MP_ERR(vo, "Cannot create framebuffer: %s\n", mp_strerror(errno));
ret = -errno;
goto end;
}
// prepare buffer for memory mapping
struct drm_mode_map_dumb mreq = {
.handle = buf->handle,
};
ret = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &mreq);
if (ret) {
MP_ERR(vo, "Cannot map dumb buffer: %s\n", mp_strerror(errno));
ret = -errno;
goto end;
}
// perform actual memory mapping
buf->map = mmap(0, buf->size, PROT_READ | PROT_WRITE, MAP_SHARED,
fd, mreq.offset);
if (buf->map == MAP_FAILED) {
MP_ERR(vo, "Cannot map dumb buffer: %s\n", mp_strerror(errno));
ret = -errno;
goto end;
}
memset(buf->map, 0, buf->size);
end:
if (ret == 0) {
return 0;
}
modeset_destroy_fb(fd, buf);
return ret;
}
static int modeset_find_crtc(struct vo *vo, int fd, drmModeRes *res,
drmModeConnector *conn, struct modeset_dev *dev)
{
for (unsigned int i = 0; i < conn->count_encoders; ++i) {
drmModeEncoder *enc = drmModeGetEncoder(fd, conn->encoders[i]);
if (!enc) {
MP_WARN(vo, "Cannot retrieve encoder %u:%u: %s\n",
i, conn->encoders[i], mp_strerror(errno));
continue;
}
// iterate all global CRTCs
for (unsigned int j = 0; j < res->count_crtcs; ++j) {
// check whether this CRTC works with the encoder
if (!(enc->possible_crtcs & (1 << j)))
continue;
dev->enc = enc;
dev->crtc = enc->crtc_id;
return 0;
}
drmModeFreeEncoder(enc);
}
MP_ERR(vo, "Connector %u has no suitable CRTC\n", conn->connector_id);
return -ENOENT;
}
static bool is_connector_valid(struct vo *vo, int conn_id,
drmModeConnector *conn, bool silent)
{
if (!conn) {
if (!silent) {
MP_ERR(vo, "Cannot get connector %d: %s\n", conn_id,
mp_strerror(errno));
}
return false;
}
if (conn->connection != DRM_MODE_CONNECTED) {
if (!silent) {
MP_ERR(vo, "Connector %d is disconnected\n", conn_id);
}
return false;
}
if (conn->count_modes == 0) {
if (!silent) {
MP_ERR(vo, "Connector %d has no valid modes\n", conn_id);
}
return false;
}
return true;
}
static int modeset_prepare_dev(struct vo *vo, int fd, int conn_id,
struct modeset_dev **out)
{
struct modeset_dev *dev = NULL;
drmModeConnector *conn = NULL;
int ret = 0;
*out = NULL;
drmModeRes *res = drmModeGetResources(fd);
if (!res) {
MP_ERR(vo, "Cannot retrieve DRM resources: %s\n", mp_strerror(errno));
ret = -errno;
goto end;
}
if (conn_id == -1) {
// get the first connected connector
for (int i = 0; i < res->count_connectors; i++) {
conn = drmModeGetConnector(fd, res->connectors[i]);
if (is_connector_valid(vo, i, conn, true)) {
conn_id = i;
break;
}
if (conn) {
drmModeFreeConnector(conn);
conn = NULL;
}
}
if (conn_id == -1) {
MP_ERR(vo, "No connected connectors found\n");
ret = -ENODEV;
goto end;
}
}
if (conn_id < 0 || conn_id >= res->count_connectors) {
MP_ERR(vo, "Bad connector ID. Max valid connector ID = %u\n",
res->count_connectors);
ret = -ENODEV;
goto end;
}
conn = drmModeGetConnector(fd, res->connectors[conn_id]);
if (!is_connector_valid(vo, conn_id, conn, false)) {
ret = -ENODEV;
goto end;
}
dev = talloc_zero(vo->priv, struct modeset_dev);
dev->conn = conn->connector_id;
dev->front_buf = 0;
dev->mode = conn->modes[0];
dev->bufs[0].width = conn->modes[0].hdisplay;
dev->bufs[0].height = conn->modes[0].vdisplay;
dev->bufs[1].width = conn->modes[0].hdisplay;
dev->bufs[1].height = conn->modes[0].vdisplay;
MP_INFO(vo, "Connector using mode %ux%u\n",
dev->bufs[0].width, dev->bufs[0].height);
ret = modeset_find_crtc(vo, fd, res, conn, dev);
if (ret) {
MP_ERR(vo, "Connector %d has no valid CRTC\n", conn_id);
goto end;
}
for (unsigned int i = 0; i < BUF_COUNT; i++) {
ret = modeset_create_fb(vo, fd, &dev->bufs[i]);
if (ret) {
MP_ERR(vo, "Cannot create framebuffer for connector %d\n",
conn_id);
for (unsigned int j = 0; j < i; j++) {
modeset_destroy_fb(fd, &dev->bufs[j]);
}
goto end;
}
}
end:
if (conn) {
drmModeFreeConnector(conn);
conn = NULL;
}
if (res) {
drmModeFreeResources(res);
res = NULL;
}
if (ret == 0) {
*out = dev;
} else {
talloc_free(dev);
}
return ret;
}
static void modeset_page_flipped(int fd, unsigned int frame, unsigned int sec,
unsigned int usec, void *data)
{
struct priv *p = data;
p->pflip_happening = false;
}
static int setup_vo_crtc(struct vo *vo)
{
struct priv *p = vo->priv;
if (p->active)
return 0;
p->old_crtc = drmModeGetCrtc(p->fd, p->dev->crtc);
int ret = drmModeSetCrtc(p->fd, p->dev->crtc,
p->dev->bufs[p->dev->front_buf + BUF_COUNT - 1].fb,
0, 0, &p->dev->conn, 1, &p->dev->mode);
p->active = true;
return ret;
}
static void release_vo_crtc(struct vo *vo)
{
struct priv *p = vo->priv;
if (!p->active)
return;
p->active = false;
// wait for current page flip
while (p->pflip_happening) {
int ret = drmHandleEvent(p->fd, &p->ev);
if (ret) {
MP_ERR(vo, "drmHandleEvent failed: %i\n", ret);
break;
}
}
if (p->old_crtc) {
drmModeSetCrtc(p->fd,
p->old_crtc->crtc_id,
p->old_crtc->buffer_id,
p->old_crtc->x,
p->old_crtc->y,
&p->dev->conn,
1,
&p->dev->mode);
drmModeFreeCrtc(p->old_crtc);
p->old_crtc = NULL;
}
}
static void release_vt(void *data)
{
struct vo *vo = data;
release_vo_crtc(vo);
if (USE_MASTER) {
//this function enables support for switching to x, weston etc.
//however, for whatever reason, it can be called only by root users.
//until things change, this is commented.
struct priv *p = vo->priv;
if (drmDropMaster(p->fd)) {
MP_WARN(vo, "Failed to drop DRM master: %s\n", mp_strerror(errno));
}
}
}
static void acquire_vt(void *data)
{
struct vo *vo = data;
if (USE_MASTER) {
struct priv *p = vo->priv;
if (drmSetMaster(p->fd)) {
MP_WARN(vo, "Failed to acquire DRM master: %s\n", mp_strerror(errno));
}
}
setup_vo_crtc(vo);
}
static int wait_events(struct vo *vo, int64_t until_time_us)
{
struct priv *p = vo->priv;
int64_t wait_us = until_time_us - mp_time_us();
int timeout_ms = MPCLAMP((wait_us + 500) / 1000, 0, 10000);
vt_switcher_poll(&p->vt_switcher, timeout_ms);
return 0;
}
static void wakeup(struct vo *vo)
{
struct priv *p = vo->priv;
vt_switcher_interrupt_poll(&p->vt_switcher);
}
static int reconfig(struct vo *vo, struct mp_image_params *params, int flags)
{
struct priv *p = vo->priv;
vo->dwidth = p->device_w;
vo->dheight = p->device_h;
vo_get_src_dst_rects(vo, &p->src, &p->dst, &p->osd);
int32_t w = p->dst.x1 - p->dst.x0;
int32_t h = p->dst.y1 - p->dst.y0;
// p->osd contains the parameters assuming OSD rendering in window
// coordinates, but OSD can only be rendered in the intersection
// between window and video rectangle (i.e. not into panscan borders).
p->osd.w = w;
p->osd.h = h;
p->osd.mt = MPMIN(0, p->osd.mt);
p->osd.mb = MPMIN(0, p->osd.mb);
p->osd.mr = MPMIN(0, p->osd.mr);
p->osd.ml = MPMIN(0, p->osd.ml);
p->x = (p->device_w - w) >> 1;
p->y = (p->device_h - h) >> 1;
mp_sws_set_from_cmdline(p->sws, vo->opts->sws_opts);
p->sws->src = *params;
p->sws->dst = (struct mp_image_params) {
.imgfmt = IMGFMT_BGR0,
.w = w,
.h = h,
.d_w = w,
.d_h = h,
};
talloc_free(p->cur_frame);
p->cur_frame = mp_image_alloc(IMGFMT_BGR0, p->device_w, p->device_h);
mp_image_params_guess_csp(&p->sws->dst);
mp_image_set_params(p->cur_frame, &p->sws->dst);
struct modeset_buf *buf = p->dev->bufs;
memset(buf[0].map, 0, buf[0].size);
memset(buf[1].map, 0, buf[1].size);
if (mp_sws_reinit(p->sws) < 0)
return -1;
vo->want_redraw = true;
return 0;
}
static void draw_image(struct vo *vo, mp_image_t *mpi)
{
struct priv *p = vo->priv;
if (p->active) {
struct mp_image src = *mpi;
struct mp_rect src_rc = p->src;
src_rc.x0 = MP_ALIGN_DOWN(src_rc.x0, mpi->fmt.align_x);
src_rc.y0 = MP_ALIGN_DOWN(src_rc.y0, mpi->fmt.align_y);
mp_image_crop_rc(&src, src_rc);
mp_sws_scale(p->sws, p->cur_frame, &src);
osd_draw_on_image(vo->osd, p->osd, src.pts, 0, p->cur_frame);
struct modeset_buf *front_buf = &p->dev->bufs[p->dev->front_buf];
int32_t shift = (p->device_w * p->y + p->x) * 4;
memcpy_pic(front_buf->map + shift,
p->cur_frame->planes[0],
(p->dst.x1 - p->dst.x0) * 4,
p->dst.y1 - p->dst.y0,
p->device_w * 4,
p->cur_frame->stride[0]);
}
if (mpi != p->last_input) {
talloc_free(p->last_input);
p->last_input = mpi;
}
}
static void flip_page(struct vo *vo)
{
struct priv *p = vo->priv;
if (!p->active || p->pflip_happening)
return;
int ret = drmModePageFlip(p->fd, p->dev->crtc,
p->dev->bufs[p->dev->front_buf].fb,
DRM_MODE_PAGE_FLIP_EVENT, p);
if (ret) {
MP_WARN(vo, "Cannot flip page for connector\n");
} else {
p->dev->front_buf++;
p->dev->front_buf %= BUF_COUNT;
p->pflip_happening = true;
}
// poll page flip finish event
const int timeout_ms = 3000;
struct pollfd fds[1] = {
{ .events = POLLIN, .fd = p->fd },
};
poll(fds, 1, timeout_ms);
if (fds[0].revents & POLLIN) {
ret = drmHandleEvent(p->fd, &p->ev);
if (ret != 0) {
MP_ERR(vo, "drmHandleEvent failed: %i\n", ret);
return;
}
}
}
static void uninit(struct vo *vo)
{
struct priv *p = vo->priv;
if (p->dev) {
release_vo_crtc(vo);
modeset_destroy_fb(p->fd, &p->dev->bufs[1]);
modeset_destroy_fb(p->fd, &p->dev->bufs[0]);
drmModeFreeEncoder(p->dev->enc);
}
vt_switcher_destroy(&p->vt_switcher);
talloc_free(p->last_input);
talloc_free(p->cur_frame);
talloc_free(p->dev);
close(p->fd);
}
static int preinit(struct vo *vo)
{
struct priv *p = vo->priv;
p->sws = mp_sws_alloc(vo);
p->fd = -1;
p->ev.version = DRM_EVENT_CONTEXT_VERSION;
p->ev.page_flip_handler = modeset_page_flipped;
if (vt_switcher_init(&p->vt_switcher, vo->log))
goto err;
vt_switcher_acquire(&p->vt_switcher, acquire_vt, vo);
vt_switcher_release(&p->vt_switcher, release_vt, vo);
if (modeset_open(vo, &p->fd, p->device_path))
goto err;
if (modeset_prepare_dev(vo, p->fd, p->connector_id, &p->dev))
goto err;
assert(p->dev);
p->device_w = p->dev->bufs[0].width;
p->device_h = p->dev->bufs[0].height;
if (setup_vo_crtc(vo)) {
MP_ERR(vo, "Cannot set CRTC for connector %u: %s\n", p->connector_id,
mp_strerror(errno));
goto err;
}
return 0;
err:
uninit(vo);
return -1;
}
static int query_format(struct vo *vo, int format)
{
return sws_isSupportedInput(imgfmt2pixfmt(format));
}
static int control(struct vo *vo, uint32_t request, void *data)
{
struct priv *p = vo->priv;
switch (request) {
case VOCTRL_SCREENSHOT_WIN:
*(struct mp_image**)data = mp_image_new_copy(p->cur_frame);
return VO_TRUE;
case VOCTRL_REDRAW_FRAME:
draw_image(vo, p->last_input);
return VO_TRUE;
case VOCTRL_GET_PANSCAN:
return VO_TRUE;
case VOCTRL_SET_PANSCAN:
if (vo->config_ok)
reconfig(vo, vo->params, 0);
return VO_TRUE;
}
return VO_NOTIMPL;
}
#define OPT_BASE_STRUCT struct priv
const struct vo_driver video_out_drm = {
.name = "drm",
.description = "Direct Rendering Manager",
.preinit = preinit,
.query_format = query_format,
.reconfig = reconfig,
.control = control,
.draw_image = draw_image,
.flip_page = flip_page,
.uninit = uninit,
.wait_events = wait_events,
.wakeup = wakeup,
.priv_size = sizeof(struct priv),
.options = (const struct m_option[]) {
OPT_STRING("devpath", device_path, 0),
OPT_INT("connector", connector_id, 0),
{0},
},
.priv_defaults = &(const struct priv) {
int main_poisson(int argc, char* argv[])
{
int yy = 128;
int zz = 128;
bool cutcorners = false;
float vardensity = 0.;
bool vd_def = false;
int T = 1;
int rnd = 0;
bool msk = true;
int points = -1;
float mindist = 1. / 1.275;
float yscale = 1.;
float zscale = 1.;
unsigned int calreg = 0;
const struct opt_s opts[] = {
OPT_INT('Y', &yy, "size", "size dimension 1"),
OPT_INT('Z', &zz, "size", "size dimension 2"),
OPT_FLOAT('y', &yscale, "acc", "acceleration dim 1"),
OPT_FLOAT('z', &zscale, "acc", "acceleration dim 2"),
OPT_UINT('C', &calreg, "size", "size of calibration region"),
OPT_SET('v', &vd_def, "variable density"),
OPT_FLOAT('V', &vardensity, "", "(variable density)"),
OPT_SET('e', &cutcorners, "elliptical scanning"),
OPT_FLOAT('D', &mindist, "", "()"),
OPT_INT('T', &T, "", "()"),
OPT_CLEAR('m', &msk, "()"),
OPT_INT('R', &points, "", "()"),
};
cmdline(&argc, argv, 1, 1, usage_str, help_str, ARRAY_SIZE(opts), opts);
if (vd_def && (0. == vardensity))
vardensity = 20.;
if (-1 != points)
rnd = 1;
assert((yscale >= 1.) && (zscale >= 1.));
// compute mindest and scaling
float kspext = MAX(yy, zz);
int Pest = T * (int)(1.2 * powf(kspext, 2.) / (yscale * zscale));
mindist /= kspext;
yscale *= (float)kspext / (float)yy;
zscale *= (float)kspext / (float)zz;
if (vardensity != 0.) {
// TODO
}
long dims[5] = { 1, yy, zz, T, 1 };
complex float* mask = NULL;
if (msk) {
mask = create_cfl(argv[1], 5, dims);
md_clear(5, dims, mask, sizeof(complex float));
}
int M = rnd ? (points + 1) : Pest;
int P;
while (true) {
float (*points)[2] = xmalloc(M * sizeof(float[3]));
int* kind = xmalloc(M * sizeof(int));
kind[0] = 0;
if (!rnd) {
points[0][0] = 0.5;
points[0][1] = 0.5;
if (1 == T) {
P = poissondisc(2, M, 1, vardensity, mindist, points);
} else {
float (*delta)[T] = xmalloc(T * T * sizeof(complex float));
float dd[T];
for (int i = 0; i < T; i++)
dd[i] = mindist;
mc_poisson_rmatrix(2, T, delta, dd);
P = poissondisc_mc(2, T, M, 1, vardensity, (const float (*)[T])delta, points, kind);
}
} else { // random pattern
P = M - 1;
for (int i = 0; i < P; i++)
random_point(2, points[i]);
}
if (P < M) {
for (int i = 0; i < P; i++) {
points[i][0] = (points[i][0] - 0.5) * yscale + 0.5;
points[i][1] = (points[i][1] - 0.5) * zscale + 0.5;
}
// throw away points outside
float center[2] = { 0.5, 0.5 };
int j = 0;
for (int i = 0; i < P; i++) {
if ((cutcorners ? dist : maxn)(2, center, points[i]) <= 0.5) {
points[j][0] = points[i][0];
points[j][1] = points[i][1];
j++;
}
}
P = j;
if (msk) {
// rethink module here
for (int i = 0; i < P; i++) {
int yy = (int)floorf(points[i][0] * dims[1]);
int zz = (int)floorf(points[i][1] * dims[2]);
if ((yy < 0) || (yy >= dims[1]) || (zz < 0) || (zz >= dims[2]))
continue;
if (1 == T)
mask[zz * dims[1] + yy] = 1.;//cexpf(2.i * M_PI * (float)kind[i] / (float)T);
else
mask[(kind[i] * dims[2] + zz) * dims[1] + yy] = 1.;//cexpf(2.i * M_PI * (float)kind[i] / (float)T);
}
} else {
#if 1
long sdims[2] = { 3, P };
complex float* samples = create_cfl(argv[1], 2, sdims);
for (int i = 0; i < P; i++) {
samples[3 * i + 0] = 0.;
samples[3 * i + 1] = (points[i][0] - 0.5) * dims[1];
samples[3 * i + 2] = (points[i][1] - 0.5) * dims[2];
// printf("%f %f\n", creal(samples[3 * i + 0]), creal(samples[3 * i + 1]));
}
unmap_cfl(2, sdims, (void*)samples);
#endif
}
break;
}
// repeat with more points
M *= 2;
free(points);
free(kind);
}
// calibration region
assert((mask != NULL) || (0 == calreg));
assert((calreg <= dims[1]) && (calreg <= dims[2]));
for (unsigned int i = 0; i < calreg; i++) {
for (unsigned int j = 0; j < calreg; j++) {
int y = (dims[1] - calreg) / 2 + i;
int z = (dims[2] - calreg) / 2 + j;
for (int k = 0; k < T; k++) {
if (0. == mask[(k * dims[2] + z) * dims[1] + y]) {
mask[(k * dims[2] + z) * dims[1] + y] = 1.;
P++;
}
}
}
}
printf("points: %d", P);
if (1 != T)
printf(", classes: %d", T);
if (NULL != mask) {
float f = cutcorners ? (M_PI / 4.) : 1.;
printf(", grid size: %ldx%ld%s = %ld (R = %f)", dims[1], dims[2], cutcorners ? "x(pi/4)" : "",
(long)(f * dims[1] * dims[2]), f * T * dims[1] * dims[2] / (float)P);
unmap_cfl(5, dims, (void*)mask);
}
printf("\n");
exit(0);
}
int main_phantom(int argc, char* argv[])
{
bool kspace = false;
bool d3 = false;
int sens = 0;
int osens = -1;
int xdim = -1;
bool out_sens = false;
bool tecirc = false;
bool circ = false;
const char* traj = NULL;
long dims[DIMS] = { [0 ... DIMS - 1] = 1 };
dims[0] = 128;
dims[1] = 128;
dims[2] = 1;
const struct opt_s opts[] = {
OPT_INT('s', &sens, "nc", "nc sensitivities"),
OPT_INT('S', &osens, "", "Output nc sensitivities"),
OPT_SET('k', &kspace, "k-space"),
OPT_STRING('t', &traj, "file", "trajectory"),
OPT_SET('c', &circ, "()"),
OPT_SET('m', &tecirc, "()"),
OPT_INT('x', &xdim, "n", "dimensions in y and z"),
OPT_SET('3', &d3, "3D"),
};
cmdline(&argc, argv, 1, 1, usage_str, help_str, ARRAY_SIZE(opts), opts);
num_init();
if (tecirc) {
circ = true;
dims[TE_DIM] = 32;
}
if (-1 != osens) {
out_sens = true;
sens = osens;
}
if (-1 != xdim)
dims[0] = dims[1] = xdim;
if (d3)
dims[2] = dims[0];
long sdims[DIMS];
complex float* samples = NULL;
if (NULL != traj) {
samples = load_cfl(traj, DIMS, sdims);
dims[0] = 1;
dims[1] = sdims[1];
dims[2] = sdims[2];
}
if (sens)
dims[3] = sens;
complex float* out = create_cfl(argv[1], DIMS, dims);
if (out_sens) {
assert(NULL == traj);
assert(!kspace);
calc_sens(dims, out);
} else
if (circ) {
assert(NULL == traj);
if (1 < dims[TE_DIM]) {
assert(!d3);
calc_moving_circ(dims, out, kspace);
} else {
(d3 ? calc_circ3d : calc_circ)(dims, out, kspace);
// calc_ring(dims, out, kspace);
}
} else {
//assert(1 == dims[COIL_DIM]);
if (NULL == samples) {
(d3 ? calc_phantom3d : calc_phantom)(dims, out, kspace);
} else {
dims[0] = 3;
(d3 ? calc_phantom3d_noncart : calc_phantom_noncart)(dims, out, samples);
dims[0] = 1;
}
}
if (NULL != traj)
free((void*)traj);
if (NULL != samples)
unmap_cfl(3, sdims, samples);
unmap_cfl(DIMS, dims, out);
return 0;
}
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include "stream.h"
#include "options/m_option.h"
#include "tv.h"
#include <stdio.h>
#define OPT_BASE_STRUCT struct tv_stream_params
static const m_option_t stream_opts_fields[] = {
OPT_STRING("channel", channel, 0),
OPT_INT("input", input, 0),
{0}
};
static void
tv_stream_close (stream_t *stream)
{
}
static int
tv_stream_open (stream_t *stream)
{
stream->type = STREAMTYPE_TV;
stream->close=tv_stream_close;
stream->demuxer = "tv";
stream->allow_caching = false;
return 1;
}
#define OPT_BASE_STRUCT struct vf_priv_s
static const m_option_t vf_opts_fields[] = {
OPT_IMAGEFORMAT("fmt", fmt, 0),
OPT_IMAGEFORMAT("outfmt", outfmt, 0),
OPT_CHOICE_C("colormatrix", colormatrix, 0, mp_csp_names),
OPT_CHOICE_C("colorlevels", colorlevels, 0, mp_csp_levels_names),
OPT_CHOICE_C("primaries", primaries, 0, mp_csp_prim_names),
OPT_CHOICE_C("gamma", gamma, 0, mp_csp_trc_names),
OPT_CHOICE_C("chroma-location", chroma_location, 0, mp_chroma_names),
OPT_CHOICE_C("stereo-in", stereo_in, 0, mp_stereo3d_names),
OPT_CHOICE_C("stereo-out", stereo_out, 0, mp_stereo3d_names),
OPT_INTRANGE("rotate", rotate, 0, -1, 359),
OPT_INT("dw", dw, 0),
OPT_INT("dh", dh, 0),
OPT_DOUBLE("dar", dar, 0),
OPT_REMOVED("outputlevels", "use the --video-output-levels global option"),
{0}
};
const vf_info_t vf_info_format = {
.description = "force output format",
.name = "format",
.open = vf_open,
.priv_size = sizeof(struct vf_priv_s),
.options = vf_opts_fields,
.priv_defaults = &(const struct vf_priv_s){
.rotate = -1,
},
int main_pics(int argc, char* argv[])
{
// Initialize default parameters
struct sense_conf conf = sense_defaults;
bool use_gpu = false;
bool randshift = true;
unsigned int maxiter = 30;
float step = -1.;
// Start time count
double start_time = timestamp();
// Read input options
struct nufft_conf_s nuconf = nufft_conf_defaults;
nuconf.toeplitz = false;
float restrict_fov = -1.;
const char* pat_file = NULL;
const char* traj_file = NULL;
bool scale_im = false;
bool eigen = false;
float scaling = 0.;
unsigned int llr_blk = 8;
const char* image_truth_file = NULL;
bool im_truth = false;
const char* image_start_file = NULL;
bool warm_start = false;
bool hogwild = false;
bool fast = false;
float admm_rho = iter_admm_defaults.rho;
unsigned int admm_maxitercg = iter_admm_defaults.maxitercg;
struct opt_reg_s ropts;
ropts.r = 0;
ropts.algo = CG;
ropts.lambda = -1.;
const struct opt_s opts[] = {
{ 'l', true, opt_reg, &ropts, "1/-l2\t\ttoggle l1-wavelet or l2 regularization." },
OPT_FLOAT('r', &ropts.lambda, "lambda", "regularization parameter"),
{ 'R', true, opt_reg, &ropts, " <T>:A:B:C\tgeneralized regularization options (-Rh for help)" },
OPT_SET('c', &conf.rvc, "real-value constraint"),
OPT_FLOAT('s', &step, "step", "iteration stepsize"),
OPT_UINT('i', &maxiter, "iter", "max. number of iterations"),
OPT_STRING('t', &traj_file, "file", "k-space trajectory"),
OPT_CLEAR('n', &randshift, "disable random wavelet cycle spinning"),
OPT_SET('g', &use_gpu, "use GPU"),
OPT_STRING('p', &pat_file, "file", "pattern or weights"),
OPT_SELECT('I', enum algo_t, &ropts.algo, IST, "(select IST)"),
OPT_UINT('b', &llr_blk, "blk", "Lowrank block size"),
OPT_SET('e', &eigen, "Scale stepsize based on max. eigenvalue"),
OPT_SET('H', &hogwild, "(hogwild)"),
OPT_SET('F', &fast, "(fast)"),
OPT_STRING('T', &image_truth_file, "file", "(truth file)"),
OPT_STRING('W', &image_start_file, "<img>", "Warm start with <img>"),
OPT_INT('d', &debug_level, "level", "Debug level"),
OPT_INT('O', &conf.rwiter, "rwiter", "(reweighting)"),
OPT_FLOAT('o', &conf.gamma, "gamma", "(reweighting)"),
OPT_FLOAT('u', &admm_rho, "rho", "ADMM rho"),
OPT_UINT('C', &admm_maxitercg, "iter", "ADMM max. CG iterations"),
OPT_FLOAT('q', &conf.cclambda, "cclambda", "(cclambda)"),
OPT_FLOAT('f', &restrict_fov, "rfov", "restrict FOV"),
OPT_SELECT('m', enum algo_t, &ropts.algo, ADMM, "Select ADMM"),
OPT_FLOAT('w', &scaling, "val", "scaling"),
OPT_SET('S', &scale_im, "Re-scale the image after reconstruction"),
};
cmdline(&argc, argv, 3, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
if (NULL != image_truth_file)
im_truth = true;
if (NULL != image_start_file)
warm_start = true;
long max_dims[DIMS];
long map_dims[DIMS];
long pat_dims[DIMS];
long img_dims[DIMS];
long coilim_dims[DIMS];
long ksp_dims[DIMS];
long traj_dims[DIMS];
// load kspace and maps and get dimensions
complex float* kspace = load_cfl(argv[1], DIMS, ksp_dims);
complex float* maps = load_cfl(argv[2], DIMS, map_dims);
complex float* traj = NULL;
if (NULL != traj_file)
traj = load_cfl(traj_file, DIMS, traj_dims);
md_copy_dims(DIMS, max_dims, ksp_dims);
md_copy_dims(5, max_dims, map_dims);
md_select_dims(DIMS, ~COIL_FLAG, img_dims, max_dims);
md_select_dims(DIMS, ~MAPS_FLAG, coilim_dims, max_dims);
if (!md_check_compat(DIMS, ~(MD_BIT(MAPS_DIM)|FFT_FLAGS), img_dims, map_dims))
error("Dimensions of image and sensitivities do not match!\n");
assert(1 == ksp_dims[MAPS_DIM]);
(use_gpu ? num_init_gpu : num_init)();
// print options
if (use_gpu)
debug_printf(DP_INFO, "GPU reconstruction\n");
if (map_dims[MAPS_DIM] > 1)
debug_printf(DP_INFO, "%ld maps.\nESPIRiT reconstruction.\n", map_dims[MAPS_DIM]);
if (hogwild)
debug_printf(DP_INFO, "Hogwild stepsize\n");
if (im_truth)
debug_printf(DP_INFO, "Compare to truth\n");
// initialize sampling pattern
complex float* pattern = NULL;
if (NULL != pat_file) {
pattern = load_cfl(pat_file, DIMS, pat_dims);
assert(md_check_compat(DIMS, COIL_FLAG, ksp_dims, pat_dims));
} else {
md_select_dims(DIMS, ~COIL_FLAG, pat_dims, ksp_dims);
pattern = md_alloc(DIMS, pat_dims, CFL_SIZE);
estimate_pattern(DIMS, ksp_dims, COIL_DIM, pattern, kspace);
}
if ((NULL != traj_file) && (NULL == pat_file)) {
md_free(pattern);
pattern = NULL;
nuconf.toeplitz = true;
} else {
// print some statistics
long T = md_calc_size(DIMS, pat_dims);
long samples = (long)pow(md_znorm(DIMS, pat_dims, pattern), 2.);
debug_printf(DP_INFO, "Size: %ld Samples: %ld Acc: %.2f\n", T, samples, (float)T / (float)samples);
}
if (NULL == traj_file) {
fftmod(DIMS, ksp_dims, FFT_FLAGS, kspace, kspace);
fftmod(DIMS, map_dims, FFT_FLAGS, maps, maps);
}
// apply fov mask to sensitivities
if (-1. != restrict_fov) {
float restrict_dims[DIMS] = { [0 ... DIMS - 1] = 1. };
restrict_dims[0] = restrict_fov;
restrict_dims[1] = restrict_fov;
restrict_dims[2] = restrict_fov;
apply_mask(DIMS, map_dims, maps, restrict_dims);
}
uninit(vo);
return -1;
}
static int validate_backend_opt(const m_option_t *opt, struct bstr name,
struct bstr param)
{
char s[20];
snprintf(s, sizeof(s), "%.*s", BSTR_P(param));
return mpgl_find_backend(s) >= -1 ? 1 : M_OPT_INVALID;
}
#define OPT_BASE_STRUCT struct gl_priv
const struct m_option options[] = {
OPT_FLAG("glfinish", use_glFinish, 0),
OPT_INT("swapinterval", swap_interval, 0, OPTDEF_INT(1)),
OPT_FLAG("debug", use_gl_debug, 0),
OPT_STRING_VALIDATE("backend", backend, 0, validate_backend_opt),
OPT_FLAG("sw", allow_sw, 0),
OPT_SUBSTRUCT("", renderer_opts, gl_video_conf, 0),
OPT_SUBSTRUCT("", icc_opts, mp_icc_conf, 0),
{0},
};
static const char help_text[];
const struct vo_driver video_out_opengl = {
.info = &(const vo_info_t) {
"Extended OpenGL Renderer",
"opengl",
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;
}
vf->config=config;
vf->query_format=query_format;
vf->filter=filter;
mp_msg(MSGT_VFILTER, MSGL_INFO, "Expand: %d x %d, %d ; %d, aspect: %f, round: %d\n",
vf->priv->cfg_exp_w,
vf->priv->cfg_exp_h,
vf->priv->cfg_exp_x,
vf->priv->cfg_exp_y,
vf->priv->aspect,
vf->priv->round);
return 1;
}
#define OPT_BASE_STRUCT struct vf_priv_s
static const m_option_t vf_opts_fields[] = {
OPT_INT("w", cfg_exp_w, 0),
OPT_INT("h", cfg_exp_h, 0),
OPT_INT("x", cfg_exp_x, M_OPT_MIN, .min = -1),
OPT_INT("y", cfg_exp_y, M_OPT_MIN, .min = -1),
OPT_DOUBLE("aspect", aspect, M_OPT_MIN, .min = 0),
OPT_INT("round", round, M_OPT_MIN, .min = 1),
{0}
};
const vf_info_t vf_info_expand = {
.description = "expanding",
.name = "expand",
.open = vf_open,
.priv_size = sizeof(struct vf_priv_s),
.priv_defaults = &vf_priv_dflt,
.options = vf_opts_fields,
int main_nlinv(int argc, char* argv[])
{
int iter = 8;
float l1 = -1.;
bool waterfat = false;
bool rvc = false;
bool normalize = true;
float restrict_fov = -1.;
float csh[3] = { 0., 0., 0. };
bool usegpu = false;
const char* psf = NULL;
const struct opt_s opts[] = {
OPT_FLOAT('l', &l1, "lambda", ""),
OPT_INT('i', &iter, "iter", ""),
OPT_SET('c', &rvc, ""),
OPT_CLEAR('N', &normalize, ""),
OPT_FLOAT('f', &restrict_fov, "FOV", ""),
OPT_STRING('p', &psf, "PSF", ""),
OPT_SET('g', &usegpu, "use gpu"),
};
cmdline(&argc, argv, 2, 3, usage_str, help_str, ARRAY_SIZE(opts), opts);
num_init();
assert(iter > 0);
long ksp_dims[DIMS];
complex float* kspace_data = load_cfl(argv[1], DIMS, ksp_dims);
long dims[DIMS];
md_copy_dims(DIMS, dims, ksp_dims);
if (waterfat)
dims[CSHIFT_DIM] = 2;
long img_dims[DIMS];
md_select_dims(DIMS, FFT_FLAGS|CSHIFT_FLAG, img_dims, dims);
long img_strs[DIMS];
md_calc_strides(DIMS, img_strs, img_dims, CFL_SIZE);
complex float* image = create_cfl(argv[2], DIMS, img_dims);
long msk_dims[DIMS];
md_select_dims(DIMS, FFT_FLAGS, msk_dims, dims);
long msk_strs[DIMS];
md_calc_strides(DIMS, msk_strs, msk_dims, CFL_SIZE);
complex float* mask;
complex float* norm = md_alloc(DIMS, msk_dims, CFL_SIZE);
complex float* sens = ((4 == argc) ? create_cfl : anon_cfl)((4 == argc) ? argv[3] : "", DIMS, ksp_dims);
complex float* pattern = NULL;
long pat_dims[DIMS];
if (NULL != psf) {
pattern = load_cfl(psf, DIMS, pat_dims);
// FIXME: check compatibility
} else {
md_copy_dims(DIMS, pat_dims, img_dims);
pattern = anon_cfl("", DIMS, pat_dims);
estimate_pattern(DIMS, ksp_dims, COIL_DIM, pattern, kspace_data);
}
if (waterfat) {
size_t size = md_calc_size(DIMS, msk_dims);
md_copy(DIMS, msk_dims, pattern + size, pattern, CFL_SIZE);
long shift_dims[DIMS];
md_select_dims(DIMS, FFT_FLAGS, shift_dims, msk_dims);
long shift_strs[DIMS];
md_calc_strides(DIMS, shift_strs, shift_dims, CFL_SIZE);
complex float* shift = md_alloc(DIMS, shift_dims, CFL_SIZE);
unsigned int X = shift_dims[READ_DIM];
unsigned int Y = shift_dims[PHS1_DIM];
unsigned int Z = shift_dims[PHS2_DIM];
for (unsigned int x = 0; x < X; x++)
for (unsigned int y = 0; y < Y; y++)
for (unsigned int z = 0; z < Z; z++)
shift[(z * Z + y) * Y + x] = cexp(2.i * M_PI * ((csh[0] * x) / X + (csh[1] * y) / Y + (csh[2] * z) / Z));
md_zmul2(DIMS, msk_dims, msk_strs, pattern + size, msk_strs, pattern + size, shift_strs, shift);
md_free(shift);
}
#if 0
float scaling = 1. / estimate_scaling(ksp_dims, NULL, kspace_data);
#else
float scaling = 100. / md_znorm(DIMS, ksp_dims, kspace_data);
#endif
debug_printf(DP_INFO, "Scaling: %f\n", scaling);
md_zsmul(DIMS, ksp_dims, kspace_data, kspace_data, scaling);
if (-1. == restrict_fov) {
mask = md_alloc(DIMS, msk_dims, CFL_SIZE);
md_zfill(DIMS, msk_dims, mask, 1.);
} else {
float restrict_dims[DIMS] = { [0 ... DIMS - 1] = 1. };
restrict_dims[0] = restrict_fov;
restrict_dims[1] = restrict_fov;
restrict_dims[2] = restrict_fov;
mask = compute_mask(DIMS, msk_dims, restrict_dims);
}
#ifdef USE_CUDA
if (usegpu) {
complex float* kspace_gpu = md_alloc_gpu(DIMS, ksp_dims, CFL_SIZE);
md_copy(DIMS, ksp_dims, kspace_gpu, kspace_data, CFL_SIZE);
noir_recon(dims, iter, l1, image, NULL, pattern, mask, kspace_gpu, rvc, usegpu);
md_free(kspace_gpu);
md_zfill(DIMS, ksp_dims, sens, 1.);
} else
#endif
noir_recon(dims, iter, l1, image, sens, pattern, mask, kspace_data, rvc, usegpu);
if (normalize) {
md_zrss(DIMS, ksp_dims, COIL_FLAG, norm, sens);
md_zmul2(DIMS, img_dims, img_strs, image, img_strs, image, msk_strs, norm);
}
if (4 == argc) {
long strs[DIMS];
md_calc_strides(DIMS, strs, ksp_dims, CFL_SIZE);
if (norm)
md_zdiv2(DIMS, ksp_dims, strs, sens, strs, sens, img_strs, norm);
fftmod(DIMS, ksp_dims, FFT_FLAGS, sens, sens);
}
md_free(norm);
md_free(mask);
unmap_cfl(DIMS, ksp_dims, sens);
unmap_cfl(DIMS, pat_dims, pattern);
unmap_cfl(DIMS, img_dims, image);
unmap_cfl(DIMS, ksp_dims, kspace_data);
exit(0);
}
/* helper macros for declaring config_options */
#define OPT_INT(key,def,field) \
{ key, def, TYPE_INT, FIELD_OFFSET(struct idmap_config, field), 0 }
#define OPT_STR(key,def,field,len) \
{ key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, field), len }
#define OPT_CLASS(key,def,index) \
{ key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, classes[index]), NAME_LEN }
#define OPT_ATTR(key,def,index) \
{ key, def, TYPE_STR, FIELD_OFFSET(struct idmap_config, attributes[index]), NAME_LEN }
/* table of recognized config options, including type and default value */
static const struct config_option g_options[] = {
/* server information */
OPT_STR("ldap_hostname", "localhost", hostname, NFS41_HOSTNAME_LEN+1),
OPT_INT("ldap_port", "389", port),
OPT_INT("ldap_version", "3", version),
OPT_INT("ldap_timeout", "0", timeout),
/* schema information */
OPT_STR("ldap_base", "cn=localhost", base, VAL_LEN),
OPT_CLASS("ldap_class_users", "user", CLASS_USER),
OPT_CLASS("ldap_class_groups", "group", CLASS_GROUP),
OPT_ATTR("ldap_attr_username", "cn", ATTR_USER_NAME),
OPT_ATTR("ldap_attr_groupname", "cn", ATTR_GROUP_NAME),
OPT_ATTR("ldap_attr_gssAuthName", "gssAuthName", ATTR_PRINCIPAL),
OPT_ATTR("ldap_attr_uidNumber", "uidNumber", ATTR_UID),
OPT_ATTR("ldap_attr_gidNumber", "gidNumber", ATTR_GID),
/* caching configuration */
OPT_INT("cache_ttl", "60", cache_ttl),