int main(int argc, char* argv[])
{
int i, niter, nw, n1, n2, n12, i1, i3, n3, iter, order;
float *mm, *dd, *dd2, *dd3, **pp, *m;
float eps, perc;
char *type, *oper;
bool verb, *known;
sf_file in, out, dip, mask=NULL;
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=20;
/* number of iterations */
if (!sf_getint("order",&nw)) nw=1;
/* [1,2,3] accuracy order */
if (nw < 1 || nw > 3)
sf_error ("Unsupported nw=%d, choose between 1 and 3",nw);
if (NULL == (type=sf_getstring("type"))) type="biorthogonal";
/* [haar,linear,biorthogonal] wavelet type, the default is biorthogonal */
if (NULL == (oper=sf_getstring("oper"))) oper="bregman";
/* [bregman,thresholding] method, the default is bregman */
if (!sf_getbool("verb",&verb)) verb = false;
/* verbosity flag */
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization parameter */
if (!sf_getfloat("perc",&perc)) perc=99.;
/* percentage for soft thresholding */
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
pp = sf_floatalloc2(n1,n2);
mm = sf_floatalloc(n12);
dd = sf_floatalloc(n12);
known = sf_boolalloc(n12);
m = sf_floatalloc(n12);
dd2 = sf_floatalloc(n12);
dd3 = sf_floatalloc(n12);
if (NULL != sf_getstring ("mask")) {
mask = sf_input("mask");
} else {
mask = NULL;
}
sf_sharpen_init(n12,perc);
seislet_init(n1,n2,true,true,eps,order,type[0]);
seislet_set(pp);
for (i3=0; i3 < n3; i3++) {
if (verb) {
sf_warning("slice %d of %d",i3+1,n3);
} else {
sf_warning("slice %d of %d;",i3+1,n3);
}
sf_floatread(dd,n12,in);
sf_floatread(pp[0],n12,dip);
if (NULL != mask) {
sf_floatread(m,n12,mask);
for (i=0; i < n12; i++) {
known[i] = (bool) (m[i] != 0.);
}
} else {
for (i=0; i < n12; i++) {
known[i] = (bool) (dd[i] != 0.);
}
}
for (i1=0; i1 < n12; i1++) {
dd2[i1] = 0.;
dd3[i1] = 0.;
}
for (iter=0; iter < niter; iter++) { /* Start iteration */
switch (oper[0]) {
case 'b':
if (verb)
sf_warning("Bregman iteration %d of %d;",iter+1,niter);
for (i1=0; i1 < n12; i1++) {
if (known[i1]) {
dd3[i1]= dd[i1]+dd3[i1]-dd2[i1];
}
}
for (i1=0; i1 < n12; i1++) {
if (known[i1]) {
dd2[i1]= 0.;
}
}
for (i1=0; i1 < n12; i1++) {
dd2[i1]+= dd3[i1];
}
break;
case 't':
if (verb)
sf_warning("Thresholding iteration %d of %d;",
iter+1,niter);
for (i1=0; i1 < n12; i1++) {
if (known[i1]) {
dd3[i1]= dd[i1]+dd3[i1]-dd2[i1];
}
}
for (i1=0; i1 < n12; i1++) {
dd2[i1] = dd3[i1];
}
break;
default:
sf_error("Unknown wavelet type=%c",oper);
break;
}
seislet_lop(true,false,n12,n12,mm,dd2);
/* Thresholding */
sf_sharpen(mm);
sf_weight_apply(n12, mm);
seislet_lop(false,false,n12,n12,mm,dd2);
} /* End interation */
for (i1=0; i1 < n12; i1++) {
dd[i1] = dd2[i1];
}
sf_floatwrite (dd,n12,out);
}
sf_sharpen_close();
sf_warning(".");
exit(0);
}
void preparation_s(sf_file Fv, sf_file Fw, sf_acqui acpar, sf_sou soupar, sf_vec_s array, sf_seis seispar)
/*< read data, initialize variables and prepare acquisition geometry >*/
{
int i, nb, nzx;
float sx, xend, rbegin, rend, tmp;
int nplo=3, nphi=3, nt;
float eps=0.0001;
sf_butter blo=NULL, bhi=NULL;
/* absorbing boundary coefficients */
nb=acpar->nb;
acpar->bc=sf_floatalloc(nb);
for(i=0; i<nb; i++){
tmp=acpar->coef*(nb-i);
acpar->bc[i]=expf(-tmp*tmp);
}
/* padding variables */
acpar->padnx=acpar->nx+2*nb;
acpar->padnz=acpar->nz+2*nb;
acpar->padx0=acpar->x0-nb*acpar->dx;
acpar->padz0=acpar->z0-nb*acpar->dz;
/* acquisition parameters */
acpar->ds_v=acpar->ds/acpar->dx+0.5;
acpar->s0_v=(acpar->s0-acpar->x0)/acpar->dx+0.5+nb;
acpar->sz += nb;
acpar->dr_v=acpar->dr/acpar->dx+0.5;
acpar->r0_v=sf_intalloc(acpar->ns);
acpar->r02=sf_intalloc(acpar->ns);
acpar->nr2=sf_intalloc(acpar->ns);
acpar->rz += nb;
xend=acpar->x0+(acpar->nx-1)*acpar->dx;
if(acpar->acqui_type==1){
for(i=0; i<acpar->ns; i++){
acpar->r0_v[i]=acpar->r0/acpar->dx+0.5+nb;
acpar->r02[i]=0;
acpar->nr2[i]=acpar->nr;
}
}else{
for(i=0; i<acpar->ns; i++){
sx=acpar->s0+acpar->ds*i;
rbegin=(sx+acpar->r0 <acpar->x0)? acpar->x0 : sx+acpar->r0;
rend=sx+acpar->r0 +(acpar->nr-1)*acpar->dr;
rend=(rend < xend)? rend : xend;
acpar->r0_v[i]=(rbegin-acpar->x0)/acpar->dx+0.5+nb;
acpar->r02[i]=(rbegin-sx-acpar->r0)/acpar->dx+0.5;
acpar->nr2[i]=(rend-rbegin)/acpar->dr+1.5;
}
}
/* read model parameters */
nzx=acpar->nz*acpar->nx;
nt=acpar->nt;
array->vv=sf_floatalloc(nzx);
array->ww=sf_floatalloc(nt);
sf_floatread(array->vv, nzx, Fv);
sf_floatread(array->ww, nt, Fw);
/* bandpass the wavelet */
soupar->flo *= acpar->dt;
soupar->fhi *= acpar->dt;
if(soupar->flo > eps) blo=sf_butter_init(false, soupar->flo, nplo);
if(soupar->fhi < 0.5-eps) bhi=sf_butter_init(true, soupar->fhi, nphi);
if(NULL != blo){
sf_butter_apply(blo, nt, array->ww);
sf_reverse(nt, array->ww);
sf_butter_apply(blo, nt, array->ww);
sf_reverse(nt, array->ww);
sf_butter_close(blo);
}
if(NULL != bhi){
sf_butter_apply(bhi, nt, array->ww);
sf_reverse(nt, array->ww);
sf_butter_apply(bhi, nt, array->ww);
sf_reverse(nt, array->ww);
sf_butter_close(bhi);
}
/* simultaneous source */
nsource=soupar->nsource;
dsource=soupar->dsource;
/* seislet regularization */
if(seispar!=NULL){
seislet=true;
seislet_init(acpar->nz, acpar->nx, true, true, seispar->eps, seispar->order, seispar->type[0]);
seislet_set(seispar->dip);
pclip=seispar->pclip;
ss=sf_floatalloc(nzx);
}
}
int main(int argc, char *argv[])
{
int i, j, n1, n2, n3, n12; /*n1 is trace length, n2 is the number of traces, n3 is the number of 3th axis*/
int order1, cut;
float *data1, *data2, /* *adata, */ **dd;
sf_file in, out, dip, slet, sletcut;
float eps;
char *type;
bool unit=false, inv=true;
sf_init(argc,argv);
in = sf_input("in");
dip=sf_input("dip");
out = sf_output("out");
slet=sf_output("slet");
sletcut=sf_output("sletcut");
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);
/* get the trace length (n1) and the number of traces (n2) and n3*/
if(!sf_getint("cut",&cut)) cut=n2/4;
/* cut threshold value */
if(!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization */
if(!sf_getint("order1",&order1))order1=1;
/* accuracy order for seislet transform*/
if (NULL == (type=sf_getstring("type"))) type="linear";
/* [haar,linear,biorthogonal] wavelet type, the default is linear */
if(!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization */
data1 = sf_floatalloc(n1*n2); /*allocate memory*/
data2 = sf_floatalloc(n1*n2); /*allocate memory*/
/* adata = sf_floatalloc(n1*n2); allocate memory*/
dd=sf_floatalloc2(n1,n2);
seislet_init(n1,n2,inv,unit,eps,order1,type[0]); /* unit=false inv=true */
for(i=0;i<n3;i++) {
sf_floatread(data1,n1*n2,in);
seislet_set(dd);
sf_floatread(dd[0],n12,dip);
seislet_lop(true,false,n12,n12,data2,data1);
/*data1 is the input raw data and data2 is the unsorted seislet domain seismic data.*/
if(NULL!=sf_getstring("slet"))
sf_floatwrite(data2,n1*n2,slet);
/* seismic domain */
/***********************************************************/
/*applying mask operator*/
for(i=cut; i<n2; i++)
for(j=0;j<n1;j++)
data2[i*n1+j]=0;
/***********************************************************/
if(NULL!=sf_getstring("sletcut"))
sf_floatwrite(data2,n1*n2,sletcut);
/* cutted seislet domain */
seislet_lop(false,false,n12,n12,data2,data1);
/*data2 is sorted seislet domain seismic data and data1 is denoised t-x domain seismic data*/
sf_floatwrite(data1,n1*n2,out);
}
exit(0);
}
