void medbin (const float *ord /* data */,
float *model /* binned */)
/*< apply median binning >*/
{
int im, id, p, np;
for (id = 0; id < nd; id++) {
if (m[id]) {
im = k[id];
bd[pt[im]] = ord[id];
pt[im]++;
}
}
for (im=0; im < nm; im++) {
np = ct[im];
if (np > 0) {
p = pt[im]-np;
model[im] =
(sf_quantile(np/2, np,bd+p)+
sf_quantile((np-1)/2,np,bd+p))*0.5;
} else {
model[im] = 0.;
}
}
}
/*------------------------------------------------------------*/
int slow3(int nr /* maximum number of references */,
float ds /* minimum slowness separation */,
int ns /* number of slownesses */,
const float* ss /* [ns] slowness array */,
float* sr /* [nr] reference slownesses squared */)
/*< compute reference slownesses, return their number >*/
{
int is,jr,ir;
float smin, smax, s, s2=0., qr, *ss2;
ss2 = sf_floatalloc(ns);
for (is=0; is<ns; is++) {
ss2[is]=ss[is];
}
smax = sf_quantile(ns-1,ns,ss2);
smin = sf_quantile( 0,ns,ss2);
nr = SF_MIN(nr,1+(smax-smin)/ds);
jr=0;
for (ir=0; ir<nr; ir++) {
qr = (ir+1.0)/nr - 0.5 * 1./nr;
s = sf_quantile(qr*ns,ns,ss2);
if (0==ir || SF_ABS(s-s2) > ds) {
sr [jr] = s*s;
s2 = s;
jr++;
}
}
free(ss2);
return jr;
}
static void getminmax(const float* f, float* min, float* max)
{
int i, m, nc;
float fmin, fmax, fi, fbig, fsml, fdif;
m=0;
fmin=+FLT_MAX;
fmax=-FLT_MAX;
for (i=0; i < n; i++) {
fi = f[i];
if (isfinite(fi)) {
t[m] = fi;
m++;
if (fmin > fi) fmin=fi;
if (fmax < fi) fmax=fi;
}
}
nc = (1.-0.01*pclip)*m;
if (nc < 0) nc=0;
if (nc >= m) nc=m-1;
if (nc > 0 && nc < m-1) {
fsml = sf_quantile(nc,m,t);
fbig = sf_quantile(m-nc-1, m,t);
fdif = fbig - fsml;
*min = SF_MAX(fmin-fdif/8,fsml-fdif);
*max = SF_MIN(fmax+fdif/8,fbig+fdif);
} else {
*min = fmin;
*max = fmax;
}
}
void impl3_set(float *** x)
/*< compute weighting function >*/
{
int i;
float a, xsum, wsum, *tmp;
sf_sobel32(n1,n2,n3,x,w);
tmp = ww[0][0];
for (i=0; i < n; i++) {
tmp[i] = w[0][0][i];
}
a = sf_quantile(nclip,n,tmp);
if (a==0.) sf_error("%s: clip at nclip=%d is zero, use a higher pclip",
__FILE__,nclip);
for (i=0; i < n; i++) {
w[0][0][i] = sqrtf(1.+w[0][0][i]/a);
if (NULL != dist) w[0][0][i] *= dist[i];
tmp[i] = 1./w[0][0][i];
if (up) w[0][0][i] = tmp[i];
}
if (verb) {
wsum = xsum = 0.;
for (i=0; i < n; i++) {
wsum += w[0][0][i];
xsum += x[0][0][i]*x[0][0][i];
}
sf_warning("xsum=%g, wsum=%g, a=%g", xsum, wsum, a);
}
}
void fixbad (int niter /* number of iterations */,
sf_filter aa /* PEF */,
int ny /* data size */,
float *yy /* in - data, out - deburst */)
/*< find bad data and restore it >*/
{
int iy;
float *rr, *rabs, rbar;
bool *known;
rr = sf_floatalloc(ny);
rabs = sf_floatalloc(ny);
known = sf_boolalloc(ny);
sf_helicon_init(aa);
sf_helicon_lop (false,false,ny,ny,yy,rr);
for (iy=0; iy < ny; iy++)
rabs[iy] = fabsf (rr[iy]);
rbar = sf_quantile(ny/2,ny,rabs);
for (iy=0; iy < ny; iy++)
known[iy] = (bool) ((yy[iy] > 0.) && (fabsf(rr[iy]) < 4. * rbar));
mis2 (niter, ny, yy, aa, known, 0., true);
free(rr);
free(rabs);
free(known);
}
void soft_thresholding(float *x, int n, float pclip)
/*< soft thresholding >*/
{
int i, m;
float *tmp, t, d;
m=0.5+n*(1-0.01*pclip);
if(m<0) m=0;
if(m>=n) m=n-1;
tmp=sf_floatalloc(n);
for(i=0; i<n; i++)
tmp[i]=fabsf(x[i]);
t=sf_quantile(m, n, tmp);
for (i=0; i<n; i++){
d=x[i];
if(d<-t){
x[i]=d+t;
}else if (d>t){
x[i]=d-t;
}else{
x[i]=0.;
}
}
free(tmp);
}
void impl1_apply (float *x)
/*< apply diffusion >*/
{
int istep, i;
float a, xsum, wsum;
/********
dx/dt = 1/w D' 1/w D u
x_{t+1} = (I + t 1/w D' 1/w D)^{-1} x_t
= (w + D' t/w D)^{-1} w x_t
*********/
for (istep=0; istep < nstep; istep++) {
sf_grad2(n,x,w);
for (i=0; i < n; i++) {
w1[i] = w[i];
}
a = sf_quantile(nclip,n,w1);
if (a==0.) sf_error("%s: clip at nclip=%d is zero, use a higher pclip",
__FILE__,nclip);
wsum = xsum = 0.;
for (i=0; i < n; i++) {
w[i] = sqrtf(1.+w[i]/a);
wsum += w[i];
xsum += x[i]*x[i];
}
sf_warning("step %d of %d, xsum=%g, wsum=%g, a=%g",
istep, nstep, xsum, wsum, a);
for (i=0; i < n; i++) {
if (up) w[i] = 1./w[i];
x[i] *= w[i];
}
for (i=0; i < n; i++) {
d1[i] = w[i];
if (up) {
w1[i] = -t*d1[i];
} else {
w1[i] = -t/d1[i];
}
}
d1[0] -= w1[0];
for (i=1; i < n-1; i++) {
d1[i] -= w1[i] + w1[i-1];
}
d1[n-1] -= w1[n-2];
sf_tridiagonal_define (slv, d1, w1);
sf_tridiagonal_solve (slv, x);
}
}
int main (int argc, char* argv[])
{
int i, j;
float xx[] = {1.,3.,4.,5.,2.};
float yy[NX];
for (i=0; i < NX; i++) {
for (j=0; j < NX; j++) {
yy[j] = xx[j];
}
printf("%d %f\n", i, sf_quantile (i, NX, yy));
}
exit (0);
}
void rweone_psc_coef(
float **aa,
float **bb,
float **a0,
float **b0)
/*< PSC coefficients >*/
{
float tt,tt2, *tb;
int ii,ir,it,ig;
float boa, boa2;
float aoa;
float bob;
if(verb) sf_warning("compute PSC coef");
/* find max(b0) */
tb=sf_floatalloc (ar.n*at.n);
ii=0;
for(it=0;it<at.n;it++) {
for(ir=0;ir<ar.n;ir++) {
tb[ii] = b0[it][ir];
ii++;
}
}
tt = SF_ABS(sf_quantile(ar.n*at.n-1,ar.n*at.n,tb));
tt2= tt*tt;
free(tb);
for(it=0;it<at.n;it++) {
for(ir=0;ir<ar.n;ir++) {
boa = ( b0[it][ir]/tt ) / a0[it][ir];
boa2=boa*boa;
for(ig=0;ig<ag.n;ig++) {
aoa = aa[it][ig]/a0[it][ir];
bob = bb[it][ig]/b0[it][ir];
m0[it][ir][ig] = 1 / tt2;
n0[it][ir][ig] = a0[it][ir] * boa2 * (c1*(aoa-1.) - (bob-1.));
r0[it][ir][ig] = 3 * c2 * boa2;
m0[it][ir][ig] *= kmu;
n0[it][ir][ig] *= knu;
r0[it][ir][ig] *= kro;
}
}
}
}
int main(int argc, char* argv[])
{
int wide1,wide2,wide3, wide, shift1, shift2, shift3, i, j, k, i1, n1, i2, n2, i3, n3, i4, n4;
float ***data, ***signal, ***win;
sf_file in, out;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
if (!sf_histint(in,"n3",&n3)) sf_error("No n3= in input");
n4 = sf_leftsize(in,3);
data = sf_floatalloc3(n1,n2,n3);
signal = sf_floatalloc3(n1,n2,n3);
if (!sf_getint("wide1",&wide1)) wide1=5;
if (!sf_getint("wide2",&wide2)) wide2=5;
if (!sf_getint("wide3",&wide3)) wide3=5;
/* sliding window width */
wide = wide1*wide2*wide3;
win = sf_floatalloc3(wide1,wide2,wide3);
for (i4=0; i4 < n4; i4++) {
sf_floatread(data[0][0],n1*n2*n3,in);
for (i3=0; i3 < n3; i3++) { shift3 = SF_MAX (0, SF_MIN (n3-wide3, i3-wide3/2));
for (i2=0; i2 < n2; i2++) { shift2 = SF_MAX (0, SF_MIN (n2-wide2, i2-wide2/2));
for (i1=0; i1 < n1; i1++) { shift1 = SF_MAX (0, SF_MIN (n1-wide1, i1-wide1/2));
for (i=0; i < wide; i++) {
for (j=0; j < wide; j++) {
for (k=0; k < wide; k++) {
win[i][j][k] = data[shift3+k][shift2+i][shift1+j];
}
}
}
signal[i3][i2][i1] = sf_quantile(wide/2,wide,win[0][0]);
}
}
}
sf_floatwrite(signal[0][0],n1*n2*n3,out);
}
exit(0);
}
void sf_cauchy (int n, const float *res, float *weight)
/*< weighting for Cauchy norm >*/
{
float rbar;
int i;
/* take absolute value */
for (i=0; i < n; i++) {
abs1[i] = fabsf(res[i]);
}
/* find median (rbar) */
rbar = sf_quantile(n/2,n,abs1);
/* weight = 1/sqrt(1+(res/rbar)^2) */
for (i=0; i < n; i++) {
weight[i] = 1./hypotf(1.,res[i]/rbar);
}
}
static float getscale(int ntest, int n1, float *abuf)
{
int i;
float dscale, f;
if (ntest == n1) { /* 100% clip - take maximum */
dscale = 0.;
for (i=0; i < n1; i++) {
f = abuf[i];
if (f > dscale) dscale=f;
}
} else {
dscale = sf_quantile(ntest,n1,abuf);
}
if (dscale > 0.) dscale=1./dscale;
return dscale;
}
int main(int argc, char* argv[])
{
int i, n, n1;
float *dat=NULL, *adat=NULL, t, pclip, d;
sf_complex *cdat=NULL;
sf_file in=NULL, out=NULL;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
n = sf_filesize(in);
adat = sf_floatalloc(n);
if (!sf_getfloat("pclip",&pclip)) sf_error("Need pclip=");
/* percentage to clip */
n1 = 0.5+n*(1.-0.01*pclip);
if (n1 < 0) n1=0;
if (n1 >= n) n1=n-1;
if (SF_FLOAT == sf_gettype(in)) {
dat = sf_floatalloc(n);
sf_floatread(dat,n,in);
for (i=0; i < n; i++) {
adat[i] = fabsf(dat[i]);
}
} else if (SF_COMPLEX == sf_gettype(in)) {
cdat = sf_complexalloc(n);
sf_complexread(cdat,n,in);
for (i=0; i < n; i++) {
adat[i] = cabsf(cdat[i]);
}
} else {
sf_error("Need float or complex input");
}
t = sf_quantile(n1,n,adat);
if (NULL != dat) {
for (i=0; i < n; i++) {
d = dat[i];
if (d < -t) {
dat[i] = d+t;
} else if (d > t) {
dat[i] = d-t;
} else {
dat[i] = 0.;
}
}
sf_floatwrite(dat,n,out);
} else {
for (i=0; i < n; i++) {
d = cabsf(cdat[i]);
if (d < -t) {
#ifdef SF_HAS_COMPLEX_H
cdat[i] *= (d+t)/d;
#else
cdat[i] = sf_crmul(cdat[i],(d+t)/d);
#endif
} else if (d > t) {
#ifdef SF_HAS_COMPLEX_H
cdat[i] *= (d-t)/d;
#else
cdat[i] = sf_crmul(cdat[i],(d-t)/d);
#endif
} else {
cdat[i] = sf_cmplx(0.,0.);
}
}
sf_complexwrite(cdat,n,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
int w1, w2, nw, s1,s2, j1,j2, i1,i2,i3, n1,n2,n3;
char *how;
float **data, **signal, **win;
sf_file in, out;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
/* get data dimensions */
if (!sf_histint(in,"n1",&n1)) sf_error("No n1=");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2=");
n3 = sf_leftsize(in,2);
/* input and output */
data = sf_floatalloc2(n1,n2);
signal = sf_floatalloc2(n1,n2);
if (!sf_getint("w1",&w1)) w1=5;
if (!sf_getint("w2",&w2)) w2=5;
/* sliding window width */
nw = w1*w2;
win = sf_floatalloc2(w1,w2);
how = sf_getstring("how");
/* what to compute
(fast median, slow median, mean) */
if (NULL == how) how="fast";
for (i3=0; i3 < n3; i3++) {
/* read data plane */
sf_floatread(data[0],n1*n2,in);
for (i2=0; i2 < n2; i2++) {
s2 = SF_MAX(0,SF_MIN(n2-w2,i2-w2/2-1));
for (i1=0; i1 < n1; i1++) {
s1 = SF_MAX(0,SF_MIN(n1-w1,i1-w1/2-1));
/* copy window */
for (j2=0; j2 < w2; j2++) {
for (j1=0; j1 < w1; j1++) {
win[j2][j1] = data[s2+j2][s1+j1];
}
}
switch (how[0]) {
case 'f': /* fast median */
signal[i2][i1] =
sf_quantile(nw/2,nw,win[0]);
break;
case 's': /* slow median */
signal[i2][i1] =
slow_median(nw,win[0]);
break;
case 'm': /* mean */
default:
/* !!! ADD CODE !!! */
break;
}
}
}
/* write out */
sf_floatwrite(signal[0],n1*n2,out);
}
exit(0);
}
int main (int argc, char* argv[])
{
int n1,n2,n3; /*n1 is trace length, n2 is the number of traces, n3 is the number of 3th axis*/
int i,j,k,kk,ii;
int nfw; /*nfw is the reference filter-window length*/
int tempnfw; /*temporary variable*/
int m;
float medianv; /*temporary median variable*/
bool boundary;
int alpha,beta,gamma,delta; /*time-varying window coefficients*/
float *trace;
float *tempt; /*temporary array*/
float *result; /*output array*/
float *extendt;
float *medianarray; /*1D median filtered array*/
float *temp1,*temp2,*temp3; /*temporary array*/
sf_file in, out;
sf_init (argc, argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n3 = sf_leftsize(in,2);
/* get the trace length (n1) and the number of traces (n2) and n3*/
if (!sf_getbool("boundary",&boundary)) boundary=false;
/* if y, boundary is data, whereas zero*/
if (!sf_getint("nfw",&nfw)) sf_error("Need integer input");
/* reference filter-window length (>delta, positive and odd integer)*/
if (!sf_getint("alpha",&alpha)) alpha=2;
/* time-varying window parameter "alpha" (default=2)*/
if (!sf_getint("beta",&beta)) beta=0;
/* time-varying window parameter "beta" (default=0)*/
if (!sf_getint("gamma",&gamma)) gamma=2;
/* time-varying window parameter "gamma" (default=2)*/
if (!sf_getint("delta",&delta)) delta=4;
/* time-varying window parameter "delta" (default=4)*/
if (alpha<beta || delta<gamma) sf_error("Need alpha>=beta && delta>=gamma");
if ((alpha%2)!=0) alpha = alpha+1;
if ((beta%2)!=0) beta = beta+1;
if ((gamma%2)!=0) gamma = gamma+1;
if ((delta%2)!=0) delta = delta+1;
if (nfw <=delta) sf_error("Need nfw > delta");
if (nfw%2 == 0) nfw++;
m=(nfw-1)/2;
tempnfw=nfw;
trace = sf_floatalloc(n1*n2);
tempt = sf_floatalloc(n1*n2);
result = sf_floatalloc(n1*n2);
extendt = sf_floatalloc((n1+2*m)*n2);
medianarray =sf_floatalloc(n1*n2);
temp1 = sf_floatalloc(nfw);
temp2 = sf_floatalloc(n1);
/*set the data space*/
for(ii=0;ii<n3;ii++){
sf_floatread(trace,n1*n2,in);
for(i=0;i<n1*n2;i++){
tempt[i]=trace[i];
}
bound1(tempt,extendt,nfw,n1,n2,boundary);
/************1D reference median filtering****************/
for(i=0;i<n2;i++){
for(j=0;j<n1;j++){
for(k=0;k<nfw;k++){
temp1[k]=extendt[(n1+2*m)*i+j+k];
}
medianarray[n1*i+j]=sf_quantile(m,nfw,temp1);
}
}
medianv=0.0;
for(i=0;i<n1*n2;i++){
medianv=medianv+fabs(medianarray[i]);
}
medianv=medianv/(1.0*n1*n2);
/************1D time-varying median filter****************/
for(i=0;i<n2;i++){
for(kk=0;kk<n1;kk++){
temp2[kk]=trace[n1*i+kk];
}
for(j=0;j<n1;j++){
if(fabs(medianarray[n1*i+j])<medianv){
if(fabs(medianarray[n1*i+j])<medianv/2.0){
tempnfw=nfw+alpha;
}
else{
tempnfw=nfw+beta;
}
}
else{
if(fabs(medianarray[n1*i+j])>=(medianv*2.0)){
tempnfw=nfw-delta;
}
else{
tempnfw=nfw-gamma;
}
}
temp3 = sf_floatalloc(tempnfw);
bound2(temp2,temp3,n1,tempnfw,j,boundary);
result[n1*i+j]=sf_quantile((tempnfw-1)/2,tempnfw,temp3);
tempnfw=nfw;
}
}
sf_floatwrite(result,n1*n2,out);
}
exit (0);
}
int main(int argc, char* argv[])
{
int n1, n2, n3, i1, i2, i3, j1, j2, k1, k2, nedge, nold, nmin, nmax, n12;
int **edge;
float **pp, **ww, **w1, **w2, g1, g2, w, min, max;
sf_file in=NULL, out=NULL;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n3 = sf_leftsize(in,2);
if (!sf_getfloat("min",&min)) min=5.0;
/* minimum threshold */
if (!sf_getfloat("max",&max)) max=95.0;
/* maximum threshold */
n12 = n1*n2;
nmin = min*0.01*n12;
if (nmin < 0) nmin=0;
if (nmin >= n12) nmin=n12-1;
nmax = max*0.01*n12;
if (nmax < 0) nmax=0;
if (nmax >= n12) nmax=n12-1;
pp = sf_floatalloc2(n1,n2);
w1 = sf_floatalloc2(n1,n2);
w2 = sf_floatalloc2(n1,n2);
ww = sf_floatalloc2(n1,n2);
edge = sf_intalloc2(n1,n2);
sf_settype(out,SF_INT);
for (i3=0; i3 < n3; i3++) {
sf_floatread(pp[0],n12,in);
/* gradient computation */
sf_sobel(n1,n2,pp,w1,w2);
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
/* gradient norm */
g1 = w1[i2][i1];
g2 = w2[i2][i1];
ww[i2][i1] = g1*g1+g2*g2;
}
}
/* edge thinning */
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
g1 = w1[i2][i1];
g2 = w2[i2][i1];
if (fabsf(g1) > fabsf(g2)) {
j1=1;
if (g2/g1 > 0.5) {
j2=1;
} else if (g2/g1 < - 0.5) {
j2=-1;
} else {
j2=0;
}
} else if (fabsf(g2) > fabsf(g1)) {
j2=1;
if (g1/g2 > 0.5) {
j1=1;
} else if (g1/g2 < - 0.5) {
j1=-1;
} else {
j1=0;
}
} else {
j1=0;
j2=0;
}
k1 = i1+j1; if (j1 && (k1 < 0 || k1 >= n1)) k1=i1;
k2 = i2+j2; if (j2 && (k2 < 0 || k2 >= n2)) k2=i2;
if (ww[i2][i1] <= ww[k2][k1]) {
pp[i2][i1] = 0.;
continue;
}
k1 = i1-j1; if (k1 < 0 || k1 >= n1) k1=i1;
k2 = i2-j2; if (k2 < 0 || k2 >= n2) k2=i2;
if (ww[i2][i1] <= ww[k2][k1]) {
pp[i2][i1] = 0.;
continue;
}
pp[i2][i1] = ww[i2][i1];
}
}
/* edge selection */
max = sf_quantile(nmax,n12,ww[0]);
min = sf_quantile(nmin,n12,ww[0]);
nedge=0;
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
w = pp[i2][i1];
if (w > max) {
edge[i2][i1] = SF_IN;
nedge++;
} else if (w < min) {
edge[i2][i1] = SF_OUT;
} else {
edge[i2][i1] = SF_FRONT;
}
}
}
nold=0;
while (nedge != nold) {
nold = nedge;
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
if (SF_FRONT == edge[i2][i1]) {
if (i2 > 0) {
if (SF_IN == edge[i2-1][i1] ||
(i1 > 0 && SF_IN == edge[i2-1][i1-1]) ||
(i1 < n1-1 && SF_IN == edge[i2-1][i1+1])) {
edge[i2][i1] = SF_IN;
nedge++;
continue;
}
}
if (i2 < n2-1) {
if (SF_IN == edge[i2+1][i1] ||
(i1 > 0 && SF_IN == edge[i2+1][i1-1]) ||
(i1 < n1-1 && SF_IN == edge[i2+1][i1+1])) {
edge[i2][i1] = SF_IN;
nedge++;
continue;
}
}
if ((i1 > 0 && SF_IN == edge[i2][i1-1]) ||
(i1 < n1-1 && SF_IN == edge[i2][i1+1])) {
edge[i2][i1] = SF_IN;
nedge++;
continue;
}
}
}
}
}
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
if (SF_FRONT == edge[i2][i1]) edge[i2][i1] = SF_OUT;
}
}
sf_intwrite(edge[0],n12,out);
}
exit(0);
}
void rweone_ffd_coef(
float **aa,
float **bb,
float **a0,
float **b0)
/*< FFD coefficients >*/
{
float ***d1, ***d2;
int ii,ir,it,ig;
float tt,tt2, *tb;
float boa, boa2, boa4;
float bob, bob2, bob4;
float aoa, aoa3;
if(verb) sf_warning("compute FFD coef");
d1=sf_floatalloc3(ag.n,ar.n,at.n);
d2=sf_floatalloc3(ag.n,ar.n,at.n);
/* find max(b0) */
tb=sf_floatalloc (ar.n*at.n);
ii=0;
for(it=0;it<at.n;it++) {
for(ir=0;ir<ar.n;ir++) {
tb[ii] = b0[it][ir];
ii++;
}
}
tt = SF_ABS(sf_quantile(ar.n*at.n-1,ar.n*at.n,tb));
tt2= tt*tt;
free(tb);
for(it=0;it<at.n;it++) {
for(ir=0;ir<ar.n;ir++) {
boa = ( b0[it][ir]/tt ) / a0[it][ir];
boa2= boa *boa ;
boa4= boa2*boa2;
for(ig=0;ig<ag.n;ig++) {
bob = bb[it][ig]/b0[it][ir];
bob2= bob *bob;
bob4= bob2*bob2;
aoa = a0[it][ir]/aa[it][ig];
aoa3= aoa*aoa*aoa;
d1[it][ir][ig] = a0[it][ir] * boa2 * ( bob2 * aoa - 1.);
d2[it][ir][ig] = a0[it][ir] * boa4 * ( bob4 * aoa3 - 1.);
}
}
}
/* regularize d1 */
for(it=0;it<at.n;it++) {
for(ir=0;ir<ar.n;ir++) {
for(ig=0;ig<ag.n;ig++) {
if( SF_ABS(d1[it][ir][ig]) < 1e-6) d1[it][ir][ig]=1e-6;
}
}
}
for(it=0;it<at.n;it++) {
for(ir=0;ir<ar.n;ir++) {
for(ig=0;ig<ag.n;ig++) {
m0[it][ir][ig] = d1[it][ir][ig] / tt2;
n0[it][ir][ig] = -c1 * d1[it][ir][ig] * d1[it][ir][ig];
r0[it][ir][ig] = c2 * d2[it][ir][ig];
m0[it][ir][ig] *= kmu;
n0[it][ir][ig] *= knu;
r0[it][ir][ig] *= kro;
}
}
}
free(**d1); free(*d1); free(d1);
free(**d2); free(*d2); free(d2);
}
int main (int argc, char* argv[])
{
int n1,n2,n3; /*n1 is trace length, n2 is the number of traces, n3 is the number of 3th axis*/
int nfw; /*nfw is the filter-window length*/
int m;
int i,j,k,ii;
bool boundary;
float *trace;
float *tempt;
float *temp1;
float *extendt;
sf_file in, out;
sf_init (argc, argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) sf_error("No n2= in input");
n3 = sf_leftsize(in,2);
/* get the trace length (n1) and the number of traces (n2) and n3*/
if (!sf_getint("nfw",&nfw)) sf_error("Need integer input");
/* filter-window length (positive and odd integer)*/
if (!sf_getbool("boundary",&boundary)) boundary=false;
/* if y, boundary is data, whereas zero*/
if (nfw < 1) sf_error("Need positive integer input");
if (nfw%2 == 0) nfw++;
m=(nfw-1)/2;
trace = sf_floatalloc(n1*n2);
tempt = sf_floatalloc(n1*n2);
temp1 = sf_floatalloc(nfw);
extendt = sf_floatalloc((n1+2*m)*n2);
for(ii=0;ii<n3;ii++){
sf_floatread(trace,n1*n2,in);
for(i=0;i<n1*n2;i++){
tempt[i]=trace[i];
}
bound1(tempt,extendt,nfw,n1,n2,boundary);
/************1D median filter****************/
for(i=0;i<n2;i++){
for(j=0;j<n1;j++){
for(k=0;k<nfw;k++){
temp1[k]=extendt[(n1+2*m)*i+j+k];
}
trace[n1*i+j]=sf_quantile(m,nfw,temp1);
}
}
sf_floatwrite(trace,n1*n2,out);
}
exit (0);
}
wexlsr3d lsr,
float **bs,
float wo /* frequency */
)
/*< k-domain weight >*/
{
int ix,iy,ii,nn;
float *ss, smin, ko;
/* find s min */
nn = cub->amx.n*cub->amy.n;
ss = sf_floatalloc(nn);
ii=0;
LOOP( ss[ii] = bs[iy][ix];
ii++; );
smin = sf_quantile(0,nn,ss);
free(ss);
ko = abs(wo) * smin;
ko *= ko;
KOOP(
if( lsr->kk[iy][ix] < ko ) {
lsr->kw[iy][ix] = 1.;
} else {
lsr->kw[iy][ix] = 0.;
} );
}
/*------------------------------------------------------------*/
void wexlsr_s2w(
int main(int argc, char* argv[])
{
bool verb, pow2;
char key[7], *mode;;
int n1, n2, n1padded, n2padded, num, dim, n[SF_MAX_DIM], npadded[SF_MAX_DIM], ii[SF_MAX_DIM];
int i, j, i1, i2, index, nw, iter, niter, nthr, *pad;
float thr, pclip, normp;
float *dobs_t, *thresh, *mask;
fftwf_complex *mm, *dd, *dobs;
fftwf_plan fft1, ifft1, fftrem, ifftrem;/* execute plan for FFT and IFFT */
sf_file in, out, Fmask; /* mask and I/O files*/
sf_init(argc,argv); /* Madagascar initialization */
in=sf_input("in"); /* read the data to be interpolated */
out=sf_output("out"); /* output the reconstructed data */
Fmask=sf_input("mask"); /* read the (n-1)-D mask for n-D data */
if(!sf_getbool("verb",&verb)) verb=false;
/* verbosity */
if(!sf_getbool("pow2",&pow2)) pow2=false;
/* round up the length of each axis to be power of 2 */
if (!sf_getint("niter",&niter)) niter=100;
/* total number of iterations */
if (!sf_getfloat("pclip",&pclip)) pclip=10.;
/* starting data clip percentile (default is 10)*/
if ( !(mode=sf_getstring("mode")) ) mode = "exp";
/* thresholding mode: 'hard', 'soft','pthresh','exp';
'hard', hard thresholding; 'soft', soft thresholding;
'pthresh', generalized quasi-p; 'exp', exponential shrinkage */
if (pclip <=0. || pclip > 100.) sf_error("pclip=%g should be > 0 and <= 100",pclip);
if (!sf_getfloat("normp",&normp)) normp=1.;
/* quasi-norm: normp<2 */
for (i=0; i < SF_MAX_DIM; i++) {/* dimensions */
snprintf(key,3,"n%d",i+1);
if (!sf_getint(key,n+i) &&
(NULL == in || !sf_histint(in,key,n+i))) break;
/*( n# size of #-th axis )*/
sf_putint(out,key,n[i]);
}
if (0==i) sf_error("Need n1=");
dim=i;
pad=sf_intalloc (dim);
for (i=0; i<dim; i++) pad[i]=0;
sf_getints("pad",pad,dim); /* number of zeros to be padded for each axis */
n1=n[0];
n2=sf_leftsize(in,1);
for (i=0; i<SF_MAX_DIM; i++) npadded[i]=1;
npadded[0]=n1+pad[0];
n1padded=npadded[0];
n2padded=1;
for (i=1; i<dim; i++){
npadded[i]=n[i]+pad[i];
if (pow2) {/* zero-padding to be power of 2 */
npadded[i]=nextpower2(n[i]);
fprintf(stderr,"n%d=%d n%dpadded=%d\n",i,n[i],i,npadded[i]);
}
n2padded*=npadded[i];
}
nw=npadded[0]/2+1;
num=nw*n2padded;/* data: total number of elements in frequency domain */
/* allocate data and mask arrays */
thresh=(float*) malloc(nw*n2padded*sizeof(float));
dobs_t=(float*) fftwf_malloc(n1padded*n2padded*sizeof(float)); /* time domain observation */
dobs=(fftwf_complex*)fftwf_malloc(nw*n2padded*sizeof(fftwf_complex));/* freq-domain observation */
dd=(fftwf_complex*) fftwf_malloc(nw*n2padded*sizeof(fftwf_complex));
mm=(fftwf_complex*) fftwf_malloc(nw*n2padded*sizeof(fftwf_complex));
if (NULL != sf_getstring("mask")){
mask=sf_floatalloc(n2padded);
} else sf_error("mask needed!");
/* initialize the input data and mask arrays */
memset(dobs_t,0,n1padded*n2padded*sizeof(float));
memset(mask,0,n2padded*sizeof(float));
for (i=0; i<n1*n2; i+=n1){
sf_line2cart(dim,n,i,ii);
j=sf_cart2line(dim,npadded,ii);
sf_floatread(&dobs_t[j], n1, in);
sf_floatread(&mask[j/n1padded], 1, Fmask);
}
/* FFT for the 1st dimension and the remaining dimensions */
fft1=fftwf_plan_many_dft_r2c(1, &n1padded, n2padded, dobs_t, &n1padded, 1, n1padded, dobs, &n1padded, 1, nw, FFTW_MEASURE);
ifft1=fftwf_plan_many_dft_c2r(1, &n1padded, n2padded, dobs, &n1padded, 1, nw, dobs_t, &n1padded, 1, n1padded, FFTW_MEASURE);
fftrem=fftwf_plan_many_dft(dim-1, &npadded[1], nw, dd, &npadded[1], nw, 1, dd, &npadded[1], nw, 1, FFTW_FORWARD, FFTW_MEASURE);
ifftrem=fftwf_plan_many_dft(dim-1, &npadded[1], nw, dd, &npadded[1], nw, 1, dd, &npadded[1], nw, 1, FFTW_BACKWARD, FFTW_MEASURE);
/* transform the data from time domain to frequency domain: dobs_t-->dobs */
fftwf_execute(fft1);
for(i=0; i<num; i++) dobs[i]/=sqrtf(n1padded);
memset(mm,0,num*sizeof(fftwf_complex));
/* Iterative Shrinkage-Thresholding (IST) Algorithm:
mm^{k+1}=T[mm^k+A^* M^* (dobs-M A mm^k)] (M^*=M; Mdobs=dobs)
=T[mm^k+A^*(dobs-M A mm^k)]; (k=0,1,...niter-1)
dd^=A mm^;
*/
for(iter=0; iter<niter; iter++)
{
/* dd<-- A mm^k */
memcpy(dd, mm, num*sizeof(fftwf_complex));
fftwf_execute(ifftrem);
for(i=0; i<num; i++) dd[i]/=sqrtf(n2padded);
/* apply mask: dd<--dobs-M A mm^k=dobs-M dd */
for(i2=0; i2<n2padded; i2++)
for(i1=0; i1<nw; i1++)
{
index=i1+nw*i2;
dd[index]=dobs[index]-mask[i2]*dd[index];
}
/* mm^k += A^*(dobs-M A mm^k); dd=dobs-M A mm^k */
fftwf_execute(fftrem);
for(i=0; i<num; i++) mm[i]+=dd[i]/sqrtf(n2padded);
/* perform thresholding */
for(i=0; i<num; i++) thresh[i]=cabsf(mm[i]);
nthr = 0.5+num*(1.-0.01*pclip); /* round off */
if (nthr < 0) nthr=0;
if (nthr >= num) nthr=num-1;
thr=sf_quantile(nthr, num, thresh);
sf_cpthresh(mm, num, thr, normp, mode);
if (verb) sf_warning("iteration %d;",iter+1);
}
/* frequency--> time domain: dobs-->dobs_t */
memcpy(dd, mm, num*sizeof(fftwf_complex));
fftwf_execute(ifftrem);
for(i=0; i<num; i++) dd[i]/=sqrtf(n2padded);
memcpy(dobs, dd, num*sizeof(fftwf_complex));
fftwf_execute(ifft1);
for(i=0; i<n1padded*n2padded; i++) dobs_t[i]/=sqrtf(n1padded);
for (i=0; i<n1*n2; i+=n1){
sf_line2cart(dim,n,i,ii);
j=sf_cart2line(dim,npadded,ii);
sf_floatwrite(&dobs_t[j],n1,out);
}
free(thresh);
fftwf_free(dobs_t);
fftwf_free(dobs);
fftwf_free(dd);
fftwf_free(mm);
exit(0);
}
int main(int argc, char* argv[])
{
int n12, i, i1, i2, rect, order, niter;
float **img, **grad, **grad1, **grad2, *y, **x;
float med, t, t2, tol[2], band;
sf_eno2 g[2];
sf_file in, out;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
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;
if (!sf_getint("rect",&rect)) rect=3;
/* smoothing radius */
t = (rect*rect-1)/6.0;
sf_runge_init(2,1,t/2);
if (!sf_getint("order",&order)) order=3;
/* interpolation order */
if (!sf_getfloat("tol",&tol[0])) tol[0]=0.1;
/* error tolerance */
tol[1]=tol[0];
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getfloat("band",&band)) band=1.;
/* narrow band */
img = sf_floatalloc2(n1,n2);
grad = sf_floatalloc2(n1,n2);
grad1 = sf_floatalloc2(n1,n2);
grad2 = sf_floatalloc2(n1,n2);
y = sf_floatalloc(n12);
x = sf_floatalloc2(2,n12);
g[0] = sf_eno2_init (order, n1, n2);
g[1] = sf_eno2_init (order, n1, n2);
sf_floatread(img[0],n12,in);
/* compute gradient squared */
sf_sobel2 (n1,n2,img,grad);
/* normalize by median */
for (i=0; i < n12; i++) {
y[i] = grad[0][i];
}
med = sf_quantile(n12/2,n12,y);
for (i=0; i < n12; i++) {
grad[0][i] = -0.5*logf(1.+grad[0][i]/med);
}
/* compute gradient */
sf_sobel (n1,n2,grad,grad1,grad2);
sf_eno2_set (g[0], grad1);
sf_eno2_set (g[1], grad2);
/* convection */
i=0;
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
if (fabsf(img[i2][i1]) < band) {
x[i][0] = i1;
x[i][1] = i2;
t2 = sf_ode23 (t,tol, x[i], g, rhs, term);
if (t2 >= t) {
y[i] = img[i2][i1];
i++;
}
}
}
}
/* diffusion */
sf_int2_init (x, 0,0,1,1,n1,n2, sf_lin_int, 2, i);
sf_triangle2_init(rect,rect, n1, n2, 1);
sf_conjgrad_init(n12, n12, i, i, 1.0/i, 1.e-8, true, false);
sf_conjgrad(NULL,
sf_int2_lop, sf_triangle2_lop, grad[0], img[0], y, niter);
sf_floatwrite(img[0],n12,out);
exit(0);
}
