int main(int argc, char* argv[])
{
int n1, n2, i2;
bool adj;
float *pp, *qq;
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");
n2 = sf_leftsize(in,1);
pp = sf_floatalloc(n1);
qq = sf_floatalloc(n1);
if (!sf_getbool("adj",&adj)) adj=false;
/* if y, do adjoint integration */
for (i2=0; i2 < n2; i2++) {
sf_floatread(pp,n1,in);
if (adj) {
sf_causint_lop (true,false,n1,n1,qq,pp);
} else {
sf_causint_lop (false,false,n1,n1,pp,qq);
}
sf_floatwrite(qq,n1,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
int n1, n2, i2, nw;
float *trace=NULL;
sf_bands spl;
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");
n2 = sf_leftsize(in,1);
if (!sf_getint("nw",&nw)) sf_error("Need nw=");
/* filter size */
trace = sf_floatalloc(n1);
spl = sf_spline_init(nw,n1);
for (i2=0; i2 < n2; i2++) {
sf_floatread(trace,n1,in);
sf_banded_solve(spl,trace);
sf_floatwrite(trace,n1,out);
}
exit(0);
}
int main (int argc, char **argv)
{
bool verb; /* verbosity flag */
bool adj;
int nt; /* number of time samples */
int nx; /* number of offsets */
int nf1, nf2, nf; /* number of filter size */
int n3, i3;
float *x, *y, *filt; /* input and output */
sf_file in, out, fil;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
fil = sf_input("filt");
if (!sf_getbool("adj",&adj)) adj=true;
/* if y, perform adjoint operation */
if (!sf_getbool ("verb",&verb)) verb=false; /* verbosity flag */
/* read input file parameters */
if (!sf_histint(in,"n1",&nt)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&nx)) sf_error("No n2= in input");
n3 = sf_leftsize(in,2);
if (!sf_histint(fil,"n1",&nf1)) sf_error("No nf1= in filt");
if (!sf_histint(fil,"n2",&nf2)) sf_error("No nf2= in filt");
if (!sf_histint(fil,"n3",&nf)) sf_error("No nf3= in filt");
if (nt != nf1 || nx != nf2 ) sf_error("Nee n1==nf1 && n2==nf2");
x = sf_floatalloc (nt*nx);
y = sf_floatalloc (nt*nx);
filt = sf_floatalloc (nt*nx*nf);
for (i3=0; i3 < n3; i3++) {
if(verb) sf_warning("i=%d of %d",i3+1,n3);
sf_floatread(filt,nt*nx*nf,fil);
matching_init(filt,nt,nx,nf);
if (adj) {
sf_floatread(y,nt*nx,in);
} else { /* modeling */
sf_floatread(x,nt*nx,in);
}
pmatching_lop (adj, false, nt*nx, nt*nx, x, y);
if (adj) {
sf_floatwrite(x,nt*nx,out);
} else { /* modeling */
sf_floatwrite(y,nt*nx,out);
}
}
exit (0);
}
int main(int argc, char* argv[])
{
int n1, n2, n3, i3;
float **pp, **qq;
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);
pp = sf_floatalloc2(n1,n2);
qq = sf_floatalloc2(n1,n2);
for (i3=0; i3 < n3; i3++) {
sf_floatread(pp[0],n1*n2,in);
sf_sobel2(n1,n2,pp,qq);
sf_floatwrite(qq[0],n1*n2,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
int j, k, n, n2, i3, n3, iter, niter;
float **a, *e, **v, s2;
sf_file mat, val, eig;
sf_init(argc,argv);
mat = sf_input("in");
val = sf_output("out");
if (SF_FLOAT != sf_gettype(mat)) sf_error("Need float input");
if (!sf_histint(mat,"n1",&n)) sf_error("No n1= in input");
if (!sf_histint(mat,"n2",&n2) || n2 != n) sf_error("Need n1=n2 in input");
n3 = sf_leftsize(mat,2);
sf_putint(val,"n2",1);
if (!sf_getint("niter",&niter)) niter=10;
a = sf_floatalloc2(n,n);
e = sf_floatalloc(n);
if (NULL != sf_getstring("eig")) {
eig = sf_output("eig"); /* eigenvectors */
v = sf_floatalloc2(n,n);
for (j=0; j < n; j++) {
for (k=0; k < n; k++) {
v[j][k] = (j==k)? 1.0:0.0;
}
}
} else {
eig = NULL;
v = NULL;
}
jacobi_init(n);
for (i3=0; i3 < n3; i3++) {
sf_floatread(a[0],n*n,mat);
for (iter=0; iter < niter; iter++) {
s2 = 0.;
for (j=0; j < n-1; j++) {
for (k=j+1; k < n; k++) {
s2 += jacobi(a,j,k,v);
}
}
sf_warning("iter=%d s2=%g",iter+1,s2);
}
for (j=0; j < n; j++) {
e[j]=a[j][j];
}
sf_floatwrite(e,n, val);
if (NULL != v) sf_floatwrite(v[0],n*n, eig);
}
exit(0);
}
int main(int argc, char* argv[])
{
int n1, n2, box1,box2,klo1,khi1,klo2,khi2,kmid1,kmid2;
float **dat,**nsum,**neg,sumA;
sf_file in, out; /* Input and output files */
/* Initialize RSF */
sf_init(argc,argv);
/* standard input */
in = sf_input("in");
/* standard output */
out = sf_output("out");
/* check that the input is float */
if (SF_FLOAT != sf_gettype(in))
sf_error("Need float input");
/* n1 is the fastest dimension (trace length) */
if (!sf_histint(in,"n1",&n1))
sf_error("No n1= in input");
/* leftsize gets n2*n3*n4*... (the number of traces) */
n2 = sf_leftsize(in,1);
/* parameter from the command line (i.e. box1=50 box2=50 ) */
if (!sf_getfloat("box1",&box1)) sf_error("Need box1=");
if (!sf_getfloat("box2",&box2)) sf_error("Nedd box2=");
/* allocate floating point array */
dat= sf_floatalloc2 (n1,n2);
/* initialise the size of the searching box*/
klo1=0;
khi1=box1;
klo2=0;
khi2=box2;
for (int klo1=0, int khi1=box1; khi1<=xmax; ++klo1,++khi1)
/* loop over traces */
for (i2=0; i2 < n2; i2++) {
/* read a trace */
sf_floatread(trace,n1,in);
/* loop over samples */
for (i1=0; i1 < n1; i1++) {
if (trace[i1] > clip) trace[i1]= clip;
else if (trace[i1] < -clip) trace[i1]=-clip;
}
/* write a trace */
sf_floatwrite(trace,n1,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
bool adj, verb;
int n1, n2, n12, n3, i3, order, ns;
float *input, *smooth, **slope, eps;
sf_file in, out, dip;
sf_init(argc,argv);
in = sf_input("in");
dip = sf_input("dip");
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);
n12 = n1*n2;
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (!sf_getint("ns",&ns)) ns=0;
/* smoothing radius */
if (!sf_getbool("adj",&adj)) adj=false;
/* adjoint flag */
if (!sf_getfloat("eps",&eps)) eps=0.01;
/* regularization */
if (!sf_getint("order",&order)) order=1;
/* accuracy order */
input = sf_floatalloc(n12);
smooth = sf_floatalloc(n12);
slope = sf_floatalloc2(n1,n2);
pwsmooth_init(ns, n1, n2, order, eps);
for (i3=0; i3 < n3; i3++) {
if (verb) sf_warning("slice %d of %d;",i3+1,n3);
sf_floatread(input,n12,in);
sf_floatread(slope[0],n12,dip);
pwsmooth_set(slope);
if (adj) {
pwsmooth_lop(true,false,n12,n12,smooth,input);
} else {
pwsmooth_lop(false,false,n12,n12,input,smooth);
}
sf_floatwrite(smooth,n12,out);
}
if (verb) sf_warning(".");
exit(0);
}
int main(int argc, char* argv[])
{
int n1, n2, i2, i, j;
float *data, sigma, rand, thresh, thresh2;
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");
n2 = sf_leftsize(in,1);
if (!sf_getfloat("sigma",&sigma)) sigma=1.;
/* noise magnitude */
if (!sf_getfloat("thresh",&thresh)) thresh=0.93;
/* noise threshold */
if (!sf_getfloat("thresh2",&thresh2)) thresh2=0.4;
/* noise threshold */
data = sf_floatalloc(n1);
for (i2=0; i2 < n2; i2++) {
sf_floatread(data,n1,in);
random_init (121794);
for (i=0; i < n1; i++) {
data[i] += (random0()-0.5)*0.001;
}
random_init (121094);
i=0;
while (i < n1) {
rand = random0();
if (rand < thresh) { /* no noise */
i++;
} else {
for (j=i; j < n1; j++) {
rand = random0();
data[j] += sigma*rand;
rand = random0();
if (rand < thresh2) break;
}
i = j + 1;
}
}
sf_floatwrite(data,n1,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
bool single;
int n1, i2, n2, nf, nc;
sf_complex *trace, *a;
sf_file in, out;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
if (SF_COMPLEX != sf_gettype(in)) sf_error("Need complex input");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_getbool("single",&single)) single=true;
/* single channel or multichannel */
if (single) {
nc = 1;
n2 = sf_leftsize(in,1);
} else {
if (!sf_histint(in,"n2",&nc)) nc=1;
n2 = sf_leftsize(in,2);
sf_putint(out,"n2",1);
}
if (!sf_getint("nf",&nf)) sf_error("Need nf=");
/* filter length */
sf_putint(out,"n1",nf);
cburg_init(n1,nc,nf);
trace = sf_complexalloc(n1*nc);
a = sf_complexalloc(nf);
for (i2=0; i2 < n2; i2++) {
sf_complexread(trace,n1*nc,in);
cburg_apply(trace,a);
sf_complexwrite(a,nf,out);
}
exit(0);
}
int main(int argc, char *argv[])
{
int i1,i2,i3,n1,n11,n2,n22,n3,n33;
float *tracein,*ref,thr;
sf_file in=NULL, simi=NULL, out=NULL;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
simi=sf_input("similarity");
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_histint(simi,"n1",&n11)) sf_error("No n1 in input");
if(!sf_histint(simi,"n2",&n22)) sf_error("No n2 in input");
n33=sf_leftsize(simi,2);
if(n1!=n11 || n2!=n22 || n3!=n33) sf_error("Dimension dismatch");
tracein=sf_floatalloc(n1);
ref=sf_floatalloc(n1);
if (!sf_getfloat("thr",&thr)) sf_error("Need thr=");
/* thresholding level */
for(i3=0;i3<n3;i3++)
{
for(i2=0;i2<n2;i2++)
{
sf_floatread(tracein,n1,in);
sf_floatread(ref,n1,simi);
for(i1=0;i1<n1;i1++)
{
if(ref[i1] < thr)
tracein[i1] = 0;
else
tracein[i1]=tracein[i1];
}
sf_floatwrite(tracein,n1,out);
}
}
exit(0);
}
int main(int argc, char* argv[])
{
int nx, nf, i2, n2, lag, niter;
bool single, verb;
float eps;
sf_complex *xx, *yy, *ff;
sf_file in, out, filt;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
filt = sf_input("filt");
if (SF_COMPLEX != sf_gettype(in) ||
SF_COMPLEX != sf_gettype(filt)) sf_error("Need float input");
if (!sf_histint(in,"n1",&nx)) sf_error("No n1= in input");
n2 = sf_leftsize(in,1);
if (!sf_histint(filt,"n1",&nf)) sf_error("No n1= in filtin");
xx = sf_complexalloc(nx);
ff = sf_complexalloc(nf);
if (!sf_getbool("single",&single)) single=true;
/* single channel or multichannel */
if (!sf_getint("lag",&lag)) lag=1;
/* lag for internal convolution */
yy = sf_complexalloc(nx);
if (!sf_getfloat("eps",&eps)) eps=1.0f;
/* regularizion parameter */
if (!sf_getint("niter",&niter)) niter=100;
/* number of iterations */
if (!sf_getbool("verb",&verb)) verb=false;
/* verbosity flag */
if (!single) sf_complexread (ff,nf,filt);
for (i2=0; i2 < n2; i2++) {
if (single) sf_complexread (ff,nf,filt);
sf_complexread (xx,nx,in);
cicai1_init(nf,ff,lag);
sf_csolver_reg(sf_ccopy_lop,sf_ccgstep,cicai1_lop,nx,nx,nx,yy,xx,niter,eps,"verb",verb,"end");
sf_ccgstep_close();
sf_complexwrite (yy,nx,out);
}
exit(0);
}
int main (int argc, char *argv[])
{
int ir, nr, n1,n2, m1, m2, n12, nw, n3;
float *u1, *u2, *p1, *p2;
sf_file in, out, ang;
omni2 ap;
sf_init(argc,argv);
in = sf_input ("in");
ang = sf_input ("dip");
out = sf_output ("out");
if (SF_FLOAT != sf_gettype(in) ||
SF_FLOAT != sf_gettype(ang)) sf_error("Need float type");
if (!sf_histint(in,"n1",&n1)) sf_error("Need n1= in input");
if (!sf_histint(in,"n2",&n2)) n2=1;
n12 = n1*n2;
nr = sf_leftsize(in,2);
if (!sf_histint(ang,"n1",&m1) || m1 != n1)
sf_error("Need n1=%d in dip",n1);
if (1 != n2 && (!sf_histint(ang,"n2",&m2) || m2 != n2))
sf_error("Need n2=%d in dip",n2);
if (!sf_histint(ang,"n3",&n3) || 2 != n3)
sf_error("Need n3=2 in dip");
if (!sf_getint("order",&nw)) nw=1;
/* accuracy */
u1 = sf_floatalloc(n12);
u2 = sf_floatalloc(n12);
p1 = sf_floatalloc(n12);
p2 = sf_floatalloc(n12);
for (ir=0; ir < nr; ir++) {
/* read dip */
sf_floatread(p1,n12,ang);
sf_floatread(p2,n12,ang);
/* read data */
sf_floatread(u1,n12,in);
ap = opwd2_init (nw,n1,n2,p1,p2);
/* apply */
opwd21(false, false, ap, u1, u2);
/* write out */
sf_floatwrite(u2,n12,out);
}
exit (0);
}
int main(int argc, char* argv[])
{
int i3, n3, ix, nx, iz, nz;
int nx2, nz2, scalex, scalez;
float dx, dz;
float **a, **b;
sf_file in, out;
sf_init(argc, argv);
in=sf_input("in");
out=sf_output("out");
if(!sf_getint("scalex", &scalex)) sf_error("Need scalex=");
if(!sf_getint("scalez", &scalez)) sf_error("Need scalez=");
if(!sf_histint(in, "n1", &nz)) sf_error("No n1= in input");
if(!sf_histfloat(in, "d1", &dz)) sf_error("No d1= in input");
if(!sf_histint(in, "n2", &nx)) sf_error("No n2= in input");
if(!sf_histfloat(in, "d2", &dx)) sf_error("No d2= in input");
nx2=(nx-1)*scalex+1;
nz2=(nz-1)*scalez+1;
n3=sf_leftsize(in, 2);
sf_putint(out, "n1", nz2);
sf_putfloat(out, "d1", dz/scalez);
sf_putint(out, "n2", nx2);
sf_putfloat(out, "d2", dx/scalex);
a=sf_floatalloc2(nz, nx);
b=sf_floatalloc2(nz2, nx2);
for (i3=0; i3<n3; i3++){
sf_floatread(a[0], nz*nx, in);
#pragma omp parallel for private(ix, iz)
for(ix=0; ix<nx2; ix++){
for(iz=0; iz<nz2; iz++){
b[ix][iz]=0.;
}
}
#pragma omp parallel for private(ix, iz)
for(ix=0; ix<nx; ix++){
for(iz=0; iz<nz; iz++){
b[ix*scalex][iz*scalez]=a[ix][iz];
}
}
sf_floatwrite(b[0], nz2*nx2, out);
}
exit(0);
}
int main(int argc, char*argv[])
{
sf_file in, out;
int nf, n1, n2, n3, m, n;
int i3;
float **wav, ****fb;
char *interp;
sf_init(argc, argv);
in = sf_input("in");
out = sf_output("out");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float type");
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);
sf_shiftdim2(in,out,2);
if(!sf_getint("m", &m)) m=1;
/* b[-m, ... ,n] */
if(!sf_getint("n", &n)) n=1;
/* b[-m, ... ,n] */
if ((interp=sf_getstring("interp"))==NULL) interp="maxflat";
/* interpolation method: maxflat lagrange bspline */
nf = m+n+1;
wav = sf_floatalloc2(n1,n2);
fb = sf_floatalloc4(n1, n2, nf, nf);
sf_putint(out, "n3", nf);
sf_putint(out, "n4", nf);
sf_putfloat(out, "o3", 0);
sf_putfloat(out, "d3", 1);
sf_putfloat(out, "o4", 0);
sf_putfloat(out, "d4", 1);
fbank_init(m, n, interp);
for(i3=0; i3<n3; i3++)
{
sf_floatread(wav[0], n1*n2, in);
fbank2(n1, n2, wav, fb);
sf_floatwrite(fb[0][0][0], n1*n2*nf*nf, out);
}
fbank_close();
return 0;
}
int main(int argc, char* argv[])
{
int nx, nf, ny, i2, n2, lag;
bool each, trans;
float *xx, *yy, *ff;
sf_file in, out, filt;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
filt = sf_input("filt");
if (SF_FLOAT != sf_gettype(in) ||
SF_FLOAT != sf_gettype(filt)) sf_error("Need float input");
if (!sf_histint(in,"n1",&nx)) sf_error("No n1= in input");
n2 = sf_leftsize(in,1);
if (!sf_histint(filt,"n1",&nf)) sf_error("No n1= in filtin");
xx = sf_floatalloc(nx);
ff = sf_floatalloc(nf);
if (!sf_getbool("trans",&trans)) trans=false;
/* if y, transient convolution; if n, internal */
if (!sf_getbool("each",&each)) each=false;
/* if y, new filter for each trace */
if (!sf_getint("lag",&lag)) lag=1;
/* lag for internal convolution */
ny = trans? (nx+nf-1)*(nx+nf-1): nx;
yy = sf_floatalloc(ny);
if (trans){
sf_putint(out,"n1",nx+nf-1);
sf_putint(out,"n2",nx+nf-1);
}
if (!each) sf_floatread (ff,nf,filt);
for (i2=0; i2 < n2; i2++) {
if (each) sf_floatread (ff,nf,filt);
sf_floatread (xx,nx,in);
if (trans) {
tcai1_ns_init(nf,ff);
tcai1_ns_lop (false, false,nx,ny,xx,yy);
} else {
icai1_init(nf,ff,lag);
icai1_lop (false, false,nx,ny,xx,yy);
}
sf_floatwrite (yy,ny,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
int n1, i1, n2, i2, na, tempna, ia, niter, center=0;
float *data;
sf_filter aa;
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");
n2 = sf_leftsize(in,1);
if (!sf_getint("na",&na)) na=3;
/* PEF length */
na--;
if (!sf_getint("niter",&niter)) niter=10;
/* number of iterations */
data = sf_floatalloc(n1);
aa = sf_allocatehelix(na);
tempna = na;
for (i2=0; i2 < n2; i2++) {
sf_floatread(data,n1,in);
aa->flt[0]=-2;
aa->flt[1]=1;
for (ia=0; ia < na; ia++) {
aa->lag[ia] = ia+1;
}
bound (1, &n1, &n1, &na, aa);
pefest (na * 2, n1, data, aa);
for (i1=0; i1 < n1; i1++) {
aa->mis[i1] = false;
}
na++;
print (1, &n1, ¢er, &na, aa);
fixbad (niter, aa, n1, data);
sf_floatwrite(data,n1,out);
na = tempna;
}
exit(0);
}
int main(int argc, char* argv[])
{
int n1, is, ns, nf, esize, pad;
off_t i2, n2;
char *trace, *zero;
sf_file in, shift;
sf_init(argc,argv);
in = sf_input("in");
shift = sf_output("out");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
n2 = sf_leftsize(in,1);
if (!sf_histint(in,"esize",&esize)) {
esize=sf_esize(in);
} else if (0>=esize) {
sf_error("cannot handle esize=%d",esize);
}
if (!sf_getint("ns",&ns)) sf_error("Need ns=");
/* number of shifts */
if (!sf_getint("nf",&nf)) nf = 1;
/* offset of first shift */
if ((nf+ns-1) >= n1) sf_error("(nf+ns-1)=%d is too large",nf+ns-1);
sf_putint(shift,"n2",ns);
sf_shiftdim(in, shift, 2);
sf_fileflush(shift,in);
sf_setform(in,SF_NATIVE);
sf_setform(shift,SF_NATIVE);
n1 *= esize;
trace = sf_charalloc(n1);
zero = sf_charalloc(n1);
memset(zero,0,n1);
for (i2=0; i2 < n2; i2++) {
sf_charread(trace,n1,in);
for (is=nf; is <= (nf+ns-1); is++) {
pad = is*esize;
sf_charwrite(zero,pad,shift);
sf_charwrite(trace,n1-pad,shift);
}
}
exit(0);
}
int main(int argc,char*argv[])
{
sf_file in, out;
int i1, i2, j2, i3, n1, n2, n3, nf;
float **u1, **u2, sigma, d2;
sf_init(argc,argv);
in = sf_input("in");
out = sf_output("out");
n3 = sf_leftsize(in, 2);
if (!sf_histint(in, "n1", &n1)) sf_error("No n1= in input file");
if (!sf_histint(in, "n2", &n2)) sf_error("No n2= in input file");
if (!sf_getfloat("sigma", &sigma)) sigma=1.0;
/* sigma */
if (!sf_getint("nf", &nf)) nf=100;
/* frequency samples [0, 0.5] */
d2 = SF_PI/(nf-1);
sf_putint(out, "n2", nf);
sf_putfloat(out, "d2", 0.5/(nf-1));
dgauss_init(n1, 1.0/sigma);
u1 = sf_floatalloc2(n1, n2);
u2 = sf_floatalloc2(n1, nf);
for (i3=0; i3<n3; i3++)
{
sf_floatread(u1[0], n1*n2, in);
for(i1=0; i1<n1; i1++)
{
for (j2=0; j2<nf; j2++)
for (i2=0; i2<n2; i2++)
{
u2[j2][i1] = u1[i2][i1] * dgauss_val(i2, d2*j2)
* powf(0.5/SF_PI, i2);
}
}
sf_floatwrite(u2[0], n1*nf, out);
}
free(u1[0]);
free(u2[0]);
free(u1);
free(u2);
dgauss_close();
exit(0);
}
int main(int argc, char*argv[])
{
int n1, n2, i1, i2;
sf_file in, out;
float *u1, *v, *p, *q, lamda, sigma;
sf_init(argc, argv);
in = sf_input("in");
out = sf_output("out");
if(!sf_getfloat("lamda", &lamda)) lamda=0.9;
if(!sf_getfloat("sigma", &sigma)) sigma=1.0;
if(!sf_histint(in, "n1", &n1)) sf_error("n1 needed in input");
n2 = sf_leftsize(in, 1);
u1 = sf_floatalloc(n1);
v = sf_floatalloc(n1);
p = sf_floatalloc(n1);
q = sf_floatalloc(n1);
for(i2=0; i2<n2; i2++)
{
sf_floatread(u1, n1, in);
v[0] = u1[0];
for(i1=1; i1<n1; i1++)
{
p[i1] = (u1[i1] - v[i1-1])/sigma;
p[i1] *= p[i1];
p[i1] = expf(-p[i1]);
v[i1] = lamda * p[i1];
v[i1] = (1-v[i1])*u1[i1] + v[i1]*v[i1-1];
}
v[n1-1] = u1[n1-1];
for(i1=n1-2; i1>=0; i1--)
{
q[i1] = (u1[i1] - v[i1+1])/sigma;
q[i1] *= q[i1];
q[i1] = expf(-q[i1]);
v[i1] = lamda * q[i1];
v[i1] = (1-v[i1])*u1[i1] + v[i1]*v[i1+1];
}
for(i1=1; i1<n1-1; i1++) v[i1] = (p[i1] * q[i1]);
v[0] = v[1]; v[n1-1] = v[n1-2];
sf_floatwrite(v, n1, out);
}
free(u1);
free(p);
free(q);
free(v);
}
int main(int argc, char* argv[])
{
char *mode=NULL; /* Standard types */
int i1,i2,n1,n2;
float *list=NULL;
sf_file in=NULL,out=NULL; /* RSF types */
sf_init(argc,argv); /* Initialize RSF */
in = sf_input("in"); /* Open files */
out = sf_output("out");
sf_fileflush(out,in); /* Copy header to output */
/* Check input data type */
if (sf_gettype(in) != SF_FLOAT) sf_error("Input must be float.");
/* Get the file sizes */
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input.");
n2 = sf_leftsize(in,1);
/* Check mode */
if ((mode = sf_getstring("mode")) == NULL) mode = "min";
/* 'min' (default) or 'max' */
if (strcmp(mode,"min")!=0 && strcmp(mode,"max")!=0)
sf_error ("Unknown mode %s.",mode);
list = sf_floatalloc(n1); /* Allocate list */
for (i2=0; i2<n2; i2++) /* Process each list */
{
sf_floatread(list,n1,in); /* Read a list */
/* Find the min or max */
if (strcmp(mode,"min")==0)
for (i1=1; i1<n1; i1++) list[i1] = SF_MIN(list[i1],list[i1-1]);
if (strcmp(mode,"max")==0)
for (i1=1; i1<n1; i1++) list[i1] = SF_MAX(list[i1],list[i1-1]);
sf_floatwrite(list,n1,out); /* Write the output */
}
exit (0);
}
int main(int argc, char* argv[])
{
int i2, n1, n2;
int order, nfw;
sf_file in, out;
float *u1;
char *filter;
void *h;
sf_init(argc, argv);
in = sf_input("in");
out = sf_output("out");
if (!sf_getint("nfw",&nfw)) nfw=5;
/* window size */
if ((filter=sf_getstring("filter"))==NULL) filter="mean";
/* filter: mean,median,poly,fir */
if (!sf_getint("order",&order)) order=nfw-1;
/* filter order (<= nfw, only for polynomial and fir filters) */
if(!sf_histint(in, "n1", &n1)) sf_error("n1 needed in input");
n2 = sf_leftsize(in, 1);
u1 = sf_floatalloc(n1);
if(strcmp(filter, "mean")==0) h = epsmean_init(n1, nfw);
else if(strcmp(filter, "median")==0) h = epsmedian_init(n1, nfw);
else if(strcmp(filter, "poly")==0) h = epspoly_init(n1, nfw, order);
else sf_error("filter %s not support", filter);
#ifdef _OPENMP
#pragma omp parallel for ordered \
schedule(dynamic,5) \
private(i2)
#endif
for(i2=0; i2<n2; i2++)
{
sf_floatread(u1, n1, in);
if(strcmp(filter, "mean")==0) epsmean(h, u1, 1);
else if(strcmp(filter, "median")==0) epsmedian(h, u1, 1);
else if(strcmp(filter, "poly")==0) epspoly(h, u1, 1);
sf_floatwrite(u1, n1, out);
}
free(u1);
return 0;
}
int main (int argc, char* argv[])
{
bool der;
int i1, n1, i2, n2, irep, nrep;
float *data, *data2, rect;
sf_file in, out;
sf_init (argc, argv);
in = sf_input ("in");
out = sf_output ("out");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
n2 = sf_leftsize(in,1);
if (!sf_getbool("der",&der)) der=false;
/* compute derivative */
if (!sf_getfloat("rect",&rect)) rect=1;
/* smoothing radius */
recgauss_init (n1,der,rect);
data = sf_floatalloc (n1);
data2 = der? sf_floatalloc (n1): NULL;
if (!sf_getint("repeat",&nrep)) nrep=1;
/* repeat filtering several times */
for (i2=0; i2 < n2; i2++) {
if (der) {
sf_floatread(data2,n1,in);
data[0] = data2[1]-data2[0];
for (i1=1; i1 < n1-1; i1++) {
data[i1] = 0.5*(data2[i1+1]-data2[i1-1]);
}
data[n1-1] = data2[n1-1]-data2[n1-2];
} else {
sf_floatread(data,n1,in);
}
for (irep=0; irep < nrep; irep++) {
recgauss (data);
}
sf_floatwrite(data,n1,out);
}
exit (0);
}
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);
}
int main(int argc, char* argv[])
{
bool verb;
int j, k, n, n2, i3, n3, iter, niter;
sf_complex **a=NULL, *e=NULL;
float s2;
sf_file mat=NULL, val=NULL;
sf_init(argc,argv);
mat = sf_input("in");
val = sf_output("out");
if (SF_COMPLEX != sf_gettype(mat)) sf_error("Need complex input");
if (!sf_histint(mat,"n1",&n)) sf_error("No n1= in input");
if (!sf_histint(mat,"n2",&n2) || n2 != n) sf_error("Need n1=n2 in input");
n3 = sf_leftsize(mat,2);
sf_putint(val,"n2",1);
if (!sf_getint("niter",&niter)) niter=10;
if (!sf_getbool("verb",&verb)) verb=false;
a = sf_complexalloc2(n,n);
e = sf_complexalloc(n);
jacobi2_init(n,verb);
for (i3=0; i3 < n3; i3++) {
sf_complexread(a[0],n*n,mat);
for (iter=0; iter < niter; iter++) {
s2 = 0.;
for (j=0; j < n; j++) {
for (k=0; k < n; k++) {
s2 += jacobi2(a,n,j,k);
}
}
sf_warning("iter=%d s2=%g",iter+1,s2);
}
for (j=0; j < n; j++) {
e[j]=a[j][j];
}
sf_complexwrite(e,n, val);
}
exit(0);
}
int main (int argc, char* argv[])
{
int i3, n3, n1, n2, n12, i, col, accum;
unsigned char* dat;
int range[NCOL];
sf_file in=NULL, out=NULL;
sf_init (argc, argv);
in = sf_input("in");
out = sf_output("out");
if (SF_UCHAR != sf_gettype(in)) sf_error("Need uchar type");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(in,"n2",&n2)) n2=1;
n3 = sf_leftsize(in,2);
n12 = n1*n2;
dat = sf_ucharalloc(n12);
for (i3=0; i3 < n3; i3++) {
sf_ucharread(dat, n12, in);
for (col=0; col < NCOL; col++) {
range[col] = 0;
}
for (i=0; i < n12; i++) {
col = dat[i];
range[col]++;
}
for (accum=0, col=0; col < NCOL; col++) {
accum += range[col];
range[col] = accum*(NCOL-1)/n12;
}
for (i=0; i < n12; i++) {
col = dat[i];
dat[i] = range[col];
}
sf_ucharwrite(dat, n12, out);
}
exit (0);
}
int main(int argc, char* argv[]) {
int n1, n2, n3, i1, i2, i3;
float t0,v0, dt,dv, t1, v1, slope,tmax,band, t,taper, *data;
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);
if (!sf_histfloat(in,"o1",&t0)) sf_error("No o1= in input");
if (!sf_histfloat(in,"d1",&dt)) sf_error("No d1= in input");
if (!sf_histfloat(in,"o2",&v0)) sf_error("No o2= in input");
if (!sf_histfloat(in,"d2",&dv)) sf_error("No d2= in input");
if (!sf_getfloat("t1",&t1)) t1=t0; // start time
if (!sf_getfloat("v1",&v1)) v1=v0+(n2-1)*dv; // end velocity
if (!sf_getfloat("band",&band)) band=20*dt; // start time
slope = (t0+(n1-1)*dt-t1)/(v1-v0);
data = sf_floatalloc(n1);
for (i3=0; i3 < n3; i3++) {
for (i2=0; i2 < n2; i2++) {
tmax = t1 + i2*dv*slope;
sf_floatread (data,n1,in);
for (i1=0; i1 < n1; i1++) {
t = t0+i1*dt;
if (t > tmax) {
data[i1] = 0.0f;
} else if (t > tmax-band) {
taper = sinf(0.5 * SF_PI * (t-tmax)/band);
data[i1] *= taper*taper;
}
}
sf_floatwrite (data,n1,out);
}
}
exit(0);
}
int main (int argc, char* argv[])
{
int n1, n2, n3, i1, i2, i3;
float *pp, x,y,u,v, *maskout;
sf_file in, out, mask;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
mask = sf_output("maskout");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
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);
pp = sf_floatalloc(n1);
maskout = sf_floatalloc(n1);
for (i3=0; i3 < n3; i3++) {
for (i2=0; i2 < n2; i2++) {
sf_floatread (pp,n1,in);
for (i1=0; i1 < n1; i1++) {
x = ((float) i1)/n1 - 0.5;
y = ((float) i2)/n2 - 0.3;
u = x+y;
v = (x-y)/2.;
if (u*u + v*v < 0.15 ) {
pp[i1] = 0.;
maskout[i1] = 0.;
} else {
maskout[i1] = 1.;
}
}
sf_floatwrite (pp,n1,out);
sf_floatwrite (maskout,n1,mask);
}
}
exit (0);
}
int main(int argc, char* argv[])
{
bool adj, inv;
int nn,n1,n2,i1,i2;
float rho, *pp=NULL;
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");
n2 = sf_leftsize(in,1);
if (!sf_getbool("adj",&adj)) adj=false;
/* If y, apply adjoint */
if (!sf_getbool("inv",&inv)) inv=false;
/* If y, do differentiation instead of integration */
if (!sf_getfloat("rho",&rho)) rho = 1.-1./n1;
/* Leaky integration constant */
if (inv) {
sf_warning("%s half-order differentiation",adj? "anticausal":"causal");
} else {
sf_warning("%s half-order integration",adj? "anticausal":"causal");
}
nn = 2*kiss_fft_next_fast_size((n1+1)/2);
pp = sf_floatalloc(nn);
sf_halfint_init (inv, nn, rho);
for (i2=0; i2 < n2; i2++) {
sf_floatread (pp,n1,in);
for (i1=n1; i1 < nn; i1++) {
pp[i1]=0.;
}
sf_halfint (adj, pp);
sf_floatwrite (pp,n1,out);
}
exit(0);
}
int main (int argc, char* argv[])
{
bool scale;
int n1,n2, i1,i2, n;
float d1, *dat, *der;
sf_file in=NULL, out=NULL;
sf_init (argc,argv);
in = sf_input("in");
out = sf_output("out");
if (SF_FLOAT != sf_gettype(in)) sf_error("Need float input");
if (!sf_histint(in,"n1",&n1)) sf_error("No n1= in input");
n2 = sf_leftsize(in,1);
dat = sf_floatalloc(n1);
der = sf_floatalloc(n1);
if (!sf_getint("order",&n)) n=6;
/* filter order */
if (!sf_getbool("scale",&scale) ||
!sf_histfloat(in,"d1",&d1)) scale=false;
/*(scale=n if scale by 1/dx )*/
sf_deriv_init(n1, n, 0.);
for (i2=0; i2 < n2; i2++) {
sf_floatread(dat,n1,in);
sf_deriv(dat,der);
if (scale) {
for (i1=0; i1 < n1; i1++) {
der[i1] /= d1;
}
}
sf_floatwrite(der,n1,out);
}
exit(0);
}
int main(int argc, char* argv[])
{
int i1, i2, n1,n2,n3,n12;
float s=0, *pp1, *pp2;
sf_file inp1, inp2, dif;
sf_init(argc,argv);
inp1 = sf_input("in");
inp2 = sf_input("match");
dif = sf_output("out");
sf_putfloat(dif,"o2",0);
sf_putfloat(dif,"o1",0);
sf_putint(dif,"n1",1);
sf_putint(dif,"n2",1);
if (!sf_histint(inp1,"n1",&n1)) sf_error("No n1= in input");
if (!sf_histint(inp1,"n2",&n2)) sf_error("No n2= in input");
if (!sf_histint(inp1,"n3",&n3)) n3=1;
n2 = sf_leftsize(inp1,1); /* left dimensions after the first one */
n12 = n1*n2;
if (n3!=1) {sf_putint(dif,"n3",1); sf_putint(dif,"d3",1); }
pp1 = sf_floatalloc(n12);
pp2 = sf_floatalloc(n12);
sf_floatread(pp1,n12,inp1);
sf_floatread(pp2,n12,inp2);
for (i2=0; i2 < n2; i2++) {
for (i1=0; i1 < n1; i1++) {
s = s + pow((pp1[i2*n1+i1]-pp2[i2*n1+i1]),2);
}
}
sf_warning("The difference is %f", s );
sf_floatwrite(&s,1,dif);
exit(0);
}
