void mis2(int niter /* number of iterations */,
int nx /* model size */,
float *xx /* model */,
sf_filter aa /* helix filter */,
const bool *known /* mask for known data */,
float eps /* regularization parameter */,
bool doprec /* to apply preconditioning */)
/*< interpolate >*/
{
int ix;
float *dd;
if (doprec) { /* preconditioned */
sf_mask_init(known);
sf_polydiv_init(nx, aa);
sf_solver_prec(sf_mask_lop, sf_cgstep, sf_polydiv_lop,
nx, nx, nx, xx, xx, niter, eps, "end");
sf_polydiv_close();
} else { /* regularized */
dd = sf_floatalloc(nx);
for (ix=0; ix < nx; ix++) {
dd[ix]=0.;
}
sf_helicon_init(aa);
sf_solver (sf_helicon_lop, sf_cgstep, nx, nx, xx, dd, niter,
"known", known, "x0", xx, "end");
free(dd);
}
sf_cgstep_close();
}
int main(int argc, char* argv[])
{
int i, ia, na, nx, ns, dim, niter;
int n[SF_MAX_DIM], m[SF_MAX_DIM], a[SF_MAX_DIM];
float a0, eps, *mm, *pp;
bool verb, *known;
sf_filter aa;
char* lagfile;
sf_file in, out, filt, lag, mask;
sf_init (argc,argv);
in = sf_input("in");
filt = sf_input("filt");
out = sf_output("out");
dim = sf_filedims (in,n);
if (!sf_histint(filt,"n1",&na)) sf_error("No n1= in filt");
aa = sf_allocatehelix (na);
if (!sf_histfloat(filt,"a0",&a0)) a0=1.;
if (!sf_histints(filt,"a",a,dim)) {
for (i=0; i < dim; i++) {
a[i]=1;
}
}
if (NULL != (lagfile = sf_getstring("lag")) /* file with filter lags */
||
NULL != (lagfile = sf_histstring(filt,"lag"))) {
lag = sf_input(lagfile);
sf_intread(aa->lag,na,lag);
} else {
lag = NULL;
for( ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
}
if (!sf_getints ("n",m,dim) && (NULL == lag ||
!sf_histints (lag,"n",m,dim))) {
for (i=0; i < dim; i++) {
m[i] = n[i];
}
}
if (NULL != lag) sf_fileclose(lag);
bound (dim, m, n, a, aa);
sf_floatread (aa->flt,na,filt);
sf_fileclose(filt);
for( ia=0; ia < na; ia++) {
aa->flt[ia] /= a0;
}
if (!sf_getint ("ns",&ns)) sf_error("Need ns=");
/* scaling */
if (!sf_getint("niter",&niter)) niter=100;
/* Number of iterations */
if (!sf_getfloat("eps",&eps)) eps=1.;
/* regularization parameter */
if (!sf_getbool("verb",&verb)) verb=true;
/* verbosity flag */
nx = 1;
for( i=0; i < dim; i++) {
nx *= n[i];
}
mm = sf_floatalloc (nx);
pp = sf_floatalloc (nx);
known = sf_boolalloc (nx);
sf_mask_init(known);
hshape_init (nx,ns,aa);
sf_conjgrad_init(nx, nx, nx, nx, eps, 1.e-8, verb, false);
if (NULL != sf_getstring("mask")) {
/* optional input mask file for known data */
mask = sf_input("mask");
sf_floatread(mm,nx,mask);
sf_fileclose(mask);
for (i=0; i < nx; i++) {
known[i] = (bool) (mm[i] != 0.);
}
sf_floatread(mm,nx,in);
} else {
sf_floatread(mm,nx,in);
for (i=0; i < nx; i++) {
known[i] = (bool) (mm[i] != 0.);
}
}
sf_conjgrad(NULL, sf_mask_lop, hshape_lop, pp, mm, mm, niter);
sf_floatwrite (mm,nx,out);
exit (0);
}
int main(int argc, char* argv[])
{
int i, niter, n1, n2, n12, i3, n3, rect1, rect2, order;
float *mm, *dd, **pp, lam;
bool *known;
sf_file in, out, dip, mask;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
dip = sf_input("dip");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n12 = n1*n2;
n3 = sf_leftsize(in,2);
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
pp = sf_floatalloc2(n1,n2);
mm = sf_floatalloc(n12);
known = sf_boolalloc(n12);
if (NULL != sf_getstring ("mask")) {
mask = sf_input("mask");
dd = sf_floatalloc(n12);
} else {
mask = NULL;
dd = NULL;
}
if (!sf_getint("rect1",&rect1)) rect1=3;
if (!sf_getint("rect2",&rect2)) rect2=3;
/* smoothing radius */
pwdsl_init(n1,n2,order,rect1,rect2,0.01);
pwdsl_set(pp);
sf_mask_init(known);
for (i3=0; i3 < n3; i3++) {
sf_warning("slice %d of %d",i3+1,n3);
sf_floatread(mm,n12,in);
if (NULL != mask) {
sf_floatread(dd,n12,mask);
} else {
dd = mm;
}
/* figure out scaling and make known data mask */
lam = 0.;
for (i=0; i < n12; i++) {
if (dd[i] != 0.) {
known[i] = true;
lam += 1.;
} else {
known[i] = false;
}
}
lam = sqrtf(lam/n12);
/* read dip */
sf_floatread(pp[0],n12,dip);
sf_conjgrad_init(n12, n12, n12, n12, lam, 10*FLT_EPSILON, true, true);
sf_conjgrad(NULL,sf_mask_lop,pwdsl_lop,dd,mm,mm,niter);
sf_conjgrad_close();
sf_floatwrite (mm,n12,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
int i, niter, n1, n2, n12, i3, n3, ns, order, np;
float *mm, *dd, *xx, **pp, **qq, lam, eps;
bool *known;
sf_file in, out, dip, mask;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
dip = sf_input("dip");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n12 = n1*n2;
n3 = sf_leftsize(in,2);
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
pp = sf_floatalloc2(n1,n2);
mm = sf_floatalloc(n12);
xx = sf_floatalloc(n12);
known = sf_boolalloc(n12);
np = sf_leftsize(dip,2);
if (np > n3) {
qq = sf_floatalloc2(n1,n2);
} else {
qq = NULL;
}
if (NULL != sf_getstring ("mask")) {
mask = sf_input("mask");
dd = sf_floatalloc(n12);
} else {
mask = NULL;
dd = NULL;
}
if (!sf_getint("ns",&ns)) ns=1;
/* smoothing radius */
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization */
sf_mask_init(known);
for (i3=0; i3 < n3; i3++) {
sf_warning("slice %d of %d",i3+1,n3);
sf_floatread(mm,n12,in);
for (i=0; i < n12; i++) {
xx[i] = mm[i];
}
if (NULL != mask) {
sf_floatread(dd,n12,mask);
} else {
dd = mm;
}
/* figure out scaling and make known data mask */
lam = 0.;
for (i=0; i < n12; i++) {
if (dd[i] != 0.) {
known[i] = true;
lam += 1.;
} else {
known[i] = false;
}
}
lam = sqrtf(lam/n12);
/* read dip */
sf_floatread(pp[0],n12,dip);
sf_conjgrad_init(n12, n12, n12, n12, lam, 10*FLT_EPSILON, true, true);
if (NULL != qq) {
sf_floatread(qq[0],n12,dip);
pwsmooth2_init(ns, n1, n2, order, eps, pp, qq);
sf_conjgrad(NULL,sf_mask_lop,pwsmooth2_lop,xx,mm,mm,niter);
pwsmooth2_close();
} else {
pwsmooth_init(ns, n1, n2, order, eps, pp);
sf_conjgrad(NULL,sf_mask_lop,pwsmooth_lop,xx,mm,mm,niter);
pwsmooth_close();
}
sf_conjgrad_close();
sf_floatwrite (mm,n12,out);
}
exit(0);
}
