Documentation:system/generic
Jump to navigation
Jump to search
Let us improve self-documentation of Madagascar programs!
Listed below are selfdocs for programs in system/generic (generated with sfdoc). Please edit the descriptions to make them more complete and/or easier to understand.
Contents
- 1 sfagc
- 2 sfaliasp
- 3 sfbandpass
- 4 sfbin
- 5 sfbin1
- 6 sfboxsmooth
- 7 sfcanny
- 8 sfcausint
- 9 sfclip
- 10 sfcmatmult
- 11 sfcmatmult2
- 12 sfcosft
- 13 sfcostaper
- 14 sfderiv
- 15 sfdipfilter
- 16 sfdwt
- 17 sfenoint2
- 18 sfequal
- 19 sfextract
- 20 sffern
- 21 sffft1
- 22 sffft3
- 23 sfgrad2
- 24 sfgrad3
- 25 sfheat
- 26 sfhistogram
- 27 sfigrad
- 28 sfimpl1
- 29 sfimpl2
- 30 sfimpl3
- 31 sfintshow
- 32 sfinttest1
- 33 sfinttest2
- 34 sfjacobi
- 35 sfjacobi2
- 36 sflapfill
- 37 sflaplac
- 38 sflinear
- 39 sflinefit
- 40 sflorenz
- 41 sflpad
- 42 sfmandelbrot
- 43 sfmatmult
- 44 sfmax1
- 45 sfmiss2
- 46 sfmonof
- 47 sfmonof2
- 48 sfmutter
- 49 sfnoise
- 50 sfotsu
- 51 sfpolymask
- 52 sfpostfilter2
- 53 sfpow
- 54 sfreg2tri
- 55 sfremap1
- 56 sfroots
- 57 sfshapebin
- 58 sfshapebin1
- 59 sfsharpen
- 60 sfslice
- 61 sfsmooth
- 62 sfsmoothder
- 63 sfsmoothreg2
- 64 sfspectra
- 65 sfspectra2
- 66 sfspline
- 67 sfsplinefilter
- 68 sfswtdenoise
- 69 sfthreshold
- 70 sftrapez
- 71 sftri2reg
- 72 sftrirand
- 73 sftrishape
- 74 sfunif2
- 75 sfunif3
sfagc
Automatic gain control. | |||
---|---|---|---|
sfagc < in.rsf > out.rsf repeat=1 rect#=(125,1,1,...) | |||
October 2011 program of the month: http://ahay.org/rsflog/index.php?/archives/271-Program-of-the-month-sfagc.html | |||
int | rect#=(125,1,1,...) | smoothing radius on #-th axis | |
int | repeat=1 | repeat filtering several times |
sfaliasp
Aliasing test. | |||
---|---|---|---|
sfaliasp > out.rsf n1=600 n2=24 cycles=10. ix0=0 slow=0.1 | |||
float | cycles=10. | wave frequency | |
int | ix0=0 | central trace | |
int | n1=600 | ||
int | n2=24 | dimensions | |
float | slow=0.1 | slowness |
sfbandpass
Bandpass filtering. | |||
---|---|---|---|
sfbandpass < in.rsf > out.rsf flo= fhi= phase=n verb=n nplo=6 nphi=6 | |||
November 2012 program of the month: http://ahay.org/rsflog/index.php?/archives/313-Program-of-the-month-sfbandpass.html | |||
float | fhi= | High frequency in band, default is Nyquist | |
float | flo= | Low frequency in band, default is 0 | |
int | nphi=6 | number of poles for high cutoff | |
int | nplo=6 | number of poles for low cutoff | |
bool | phase=n | [y/n] | y: minimum phase, n: zero phase |
bool | verb=n | [y/n] | verbosity flag |
sfbin
Data binning in 2-D slices. | |||
---|---|---|---|
sfbin < in.rsf > out.rsf fold=fold.rsf xkey=0 ykey=1 xmax= xmin= ymax= ymin= x0=xmin y0=ymin nx=(int) (xmax - xmin + 1.) ny=(int) (ymax - ymin + 1.) dx= dy= interp=1 norm=y clip=FLT_EPSILON head= | |||
float | clip=FLT_EPSILON | clip for fold normalization | |
float | dx= | bin size in x | |
float | dy= | bin size in y | |
string | fold= | output file for fold (optional) (auxiliary output file name) | |
string | head= | header file | |
int | interp=1 | [0,1,2] | interpolation method;
|
bool | norm=y | [y/n] | if normalize |
int | nx=(int) (xmax - xmin + 1.) | Number of bins in x | |
int | ny=(int) (ymax - ymin + 1.) | Number of bins in y | |
float | x0=xmin | x origin | |
int | xkey=0 | x key number | |
float | xmax= | x maximum | |
float | xmin= | x minimum | |
float | y0=ymin | y origin | |
int | ykey=1 | y key number | |
float | ymax= | y maximum | |
float | ymin= | y minimum |
sfbin1
Data binning in 1-D slices. | |||
---|---|---|---|
sfbin1 < in.rsf > out.rsf pattern=pattern.rsf fold=fold.rsf xmin= xmax= nx= x0=xmin dx= interp=1 clip=FLT_EPSILON head= | |||
float | clip=FLT_EPSILON | clip for fold normalization | |
float | dx= | grid spacing | |
string | fold= | output fold file (optional) (auxiliary output file name) | |
string | head= | ||
int | interp=1 | [1,2] | interpolation method, 1: nearest neighbor, 2: linear |
int | nx= | Number of bins | |
string | pattern= | auxiliary input file name | |
float | x0=xmin | grid origin | |
float | xmax= | ||
float | xmin= | grid dimensions |
sfboxsmooth
Multi-dimensional smoothing with boxes. | |||
---|---|---|---|
sfboxsmooth < in.rsf > out.rsf repeat=1 rect#=(1,1,...) | |||
int | rect#=(1,1,...) | smoothing radius on #-th axis | |
int | repeat=1 | repeat filtering several times |
sfcanny
Canny-like edge detector. | |||
---|---|---|---|
sfcanny < in.rsf > out.rsf min=5.0 max=95.0 | |||
float | max=95.0 | maximum threshold | |
float | min=5.0 | minimum threshold |
sfcausint
Causal integration on the first axis. | |||
---|---|---|---|
sfcausint < in.rsf > out.rsf adj=n | |||
bool | adj=n | [y/n] | if y, do adjoint integration |
sfclip
Clip the data. | |||
---|---|---|---|
sfclip < in.rsf > out.rsf clip= | |||
The output is clip if input > clip -clip if input < -clip input if |input| < clip See also sfclip2. September 2011 program of the month: http://ahay.org/rsflog/index.php?/archives/269-Program-of-the-month-sfclip.html | |||
float | clip= | clip value |
sfcmatmult
Simple matrix multiplication for complex matrices | |||
---|---|---|---|
sfcmatmult < in.rsf > out.rsf mat=mat.rsf adj=n | |||
bool | adj=n | [y/n] | |
file | mat= | auxiliary input file name |
sfcmatmult2
Multiplication of two complex matrices | |||
---|---|---|---|
sfcmatmult2 < in.rsf > out.rsf mat=mat.rsf | |||
file | mat= | auxiliary input file name |
sfcosft
Multi-dimensional cosine transform. | |||
---|---|---|---|
sfcosft < in.rsf > out.rsf sign#=0 | |||
The input and output are real and have the same dimensions. Pad the data if you need to suppress wrap-around effects. | |||
int | sign#=0 | transform along #-th dimension [+1 forward or -1 backward] |
sfcostaper
Cosine taper around the borders (N-D). | |||
---|---|---|---|
sfcostaper < in.rsf > out.rsf nw#=0 | |||
int | nw#=0 | tapering on #-th axis |
sfderiv
First derivative with a maximally linear FIR differentiator. | |||
---|---|---|---|
sfderiv < in.rsf > out.rsf order=6 scale=n | |||
May 2012 program of the month: http://ahay.org/rsflog/index.php?/archives/290-Program-of-the-month-sfderiv.html | |||
int | order=6 | filter order | |
bool | scale=n | [y/n] | if scale by 1/dx |
sfdipfilter
Filter data based on dip in 2-D or 3-D. | |||
---|---|---|---|
sfdipfilter < in.rsf > out.rsf dim=2 angle=n v=-1. ang1=-50. ang2=-45. ang3=45. ang4=50. v1=0. v2=0.1 v3=99999. v4=999999. pass=y | |||
float | ang1=-50. | ||
float | ang2=-45. | ||
float | ang3=45. | ||
float | ang4=50. | Angle gate (in degrees) | |
bool | angle=n | [y/n] | Filter based on angle (or velocity) |
int | dim=2 | [2,3] | Dimensionality: filter 2-D planes or 3-D cubes |
bool | pass=y | [y/n] | Pass or reject band |
float | v=-1. | constant velocity (if angle-y)
| |
float | v1=0. | ||
float | v2=0.1 | ||
float | v3=99999. | ||
float | v4=999999. | Velocity gate |
sfdwt
1-D digital wavelet transform | |||
---|---|---|---|
sfdwt < in.rsf > out.rsf inv=n adj=n unit=n type= | |||
bool | adj=n | [y/n] | if y, do adjoint transform |
bool | inv=n | [y/n] | if y, do inverse transform |
string | type= | [haar,linear,biorthogonal] wavelet type, the default is linear | |
bool | unit=n | [y/n] | if y, use unitary scaling |
sfenoint2
ENO interpolation in 2-D slices. | |||
---|---|---|---|
sfenoint2 < in.rsf > out.rsf head=head.rsf xkey= ykey= interp=2 | |||
file | head= | auxiliary input file name | |
int | interp=2 | interpolation order | |
int | xkey= | x key number | |
int | ykey= | y key number |
sfequal
Image enhancement by histogram equalization. | |||
---|---|---|---|
sfequal < in.rsf > out.rsf |
sfextract
Forward interpolation in 2-D slices. | |||
---|---|---|---|
sfextract < in.rsf > out.rsf head=head.rsf xkey=0 ykey=1 interp=2 | |||
file | head= | auxiliary input file name | |
int | interp=2 | [1,2] | interpolation method, 1: nearest neighbor, 2: bi-linear |
int | xkey=0 | x key number | |
int | ykey=1 | y key number |
sffern
Generate fractal fern. | |||
---|---|---|---|
sffern > out.rsf n=1000 seed=time(NULL) angle=y | |||
bool | angle=y | [y/n] | if y, use more angular fern |
int | n=1000 | number of points | |
int | seed=time(NULL) | random seed |
sffft1
Fast Fourier Transform along the first axis. | |||
---|---|---|---|
sffft1 < in.rsf > out.rsf inv=n sym=n opt=y | |||
bool | inv=n | [y/n] | if y, perform inverse transform |
bool | opt=y | [y/n] | if y, determine optimal size for efficiency |
bool | sym=n | [y/n] | if y, apply symmetric scaling to make the FFT operator Hermitian |
sffft3
FFT transform on extra axis. | |||
---|---|---|---|
sffft3 < in.rsf > out.rsf inv=n sym=n sign=inv? 1: 0 opt=y axis=2 pad=2 | |||
Input and output are complex data. The input is padded by factor pad. July 2012 program of the month: http://ahay.org/rsflog/index.php?/archives/298-Program-of-the-month-sffft3.html | |||
int | axis=2 | Axis to transform | |
bool | inv=n | [y/n] | if y, perform inverse transform |
bool | opt=y | [y/n] | if y, determine optimal size for efficiency |
int | pad=2 | padding factor | |
int | sign=inv? 1: 0 | transform sign (0 or 1) | |
bool | sym=n | [y/n] | if y, apply symmetric scaling to make the FFT operator Hermitian |
sfgrad2
2-D smooth gradient. | |||
---|---|---|---|
sfgrad2 < in.rsf > out.rsf |
sfgrad3
3-D smooth gradient. | |||
---|---|---|---|
sfgrad3 < in.rsf > out.rsf |
sfheat
Finite-difference solution of 2-D heat-flow equation | |||
---|---|---|---|
sfheat > out.rsf impl=n alpha=1. | |||
float | alpha=1. | ||
bool | impl=n | [y/n] | if y, use implicit scheme |
sfhistogram
Compute a histogram of integer- or float-valued input data. | |||
---|---|---|---|
sfhistogram < in.rsf > out.rsf n1= o1= d1= | |||
The output grid is not centered on the bins; it marks their "left edge". I.e., the first sample holds the number of values between o1 and o1+d1. | |||
float | d1= | histogram sampling | |
int | n1= | number of histogram samples | |
float | o1= | histogram origin |
sfigrad
Gradient on the first axis. | |||
---|---|---|---|
sfigrad < in.rsf > out.rsf square=n adj=n | |||
bool | adj=n | [y/n] | adjoint flag |
bool | square=n | [y/n] | if y, use gradient squared |
sfimpl1
1-D anisotropic diffusion. | |||
---|---|---|---|
sfimpl1 < in.rsf > out.rsf rect1= tau=0.1 pclip=50. up=n | |||
float | pclip=50. | percentage clip for the gradient | |
float | rect1= | smoothing radius | |
float | tau=0.1 | smoothing time | |
bool | up=n | [y/n] | smoothing style |
sfimpl2
2-D anisotropic diffusion. | |||
---|---|---|---|
sfimpl2 < in.rsf > out.rsf rect1= rect2= tau=0.1 pclip=50. up=n verb=n nsnap=1 lin=n adj=n dist= snap= | |||
bool | adj=n | [y/n] | adjoint flag |
string | dist= | inverse distance file (input) | |
bool | lin=n | [y/n] | if linear operator |
int | nsnap=1 | number of snapshots | |
float | pclip=50. | percentage clip for the gradient | |
float | rect1= | vertical smoothing | |
float | rect2= | horizontal smoothing | |
string | snap= | snapshot file (output) | |
float | tau=0.1 | smoothing time | |
bool | up=n | [y/n] | smoothing style |
bool | verb=n | [y/n] | verbosity flag |
sfimpl3
3-D anisotropic diffusion. | |||
---|---|---|---|
sfimpl3 < in.rsf > out.rsf rect1= rect2= rect3= tau=0.1 pclip=50. up=n verb=n nsnap=1 dist= snap= | |||
string | dist= | inverse distance file (input) | |
int | nsnap=1 | number of snapshots | |
float | pclip=50. | percentage clip for the gradient | |
float | rect1= | ||
float | rect2= | ||
float | rect3= | smoothing radius | |
string | snap= | snapshot file (output) | |
float | tau=0.1 | smoothing time | |
bool | up=n | [y/n] | smoothing style |
bool | verb=n | [y/n] | verbosity flag |
sfintshow
Output interpolation filter. | |||
---|---|---|---|
sfintshow > filt.rsf nw= x= kai=4.0 interp= | |||
See also: inttest1. | |||
string | interp= | interpolation (lagrange,cubic,kaiser,lanczos,cosine,welch,spline,mom) | |
float | kai=4.0 | Kaiser window parameter | |
int | nw= | interpolator size | |
float | x= | interpolation shift |
sfinttest1
Interpolation from a regular grid in 1-D. | |||
---|---|---|---|
sfinttest1 < in.rsf > out.rsf coord=crd.rsf nw= kai=4.0 interp= | |||
file | coord= | auxiliary input file name | |
string | interp= | interpolation (lagrange,cubic,kaiser,lanczos,cosine,welch,spline,mom) | |
float | kai=4.0 | Kaiser window parameter | |
int | nw= | interpolator size |
sfinttest2
Interpolation from a regular grid in 2-D. | |||
---|---|---|---|
sfinttest2 < in.rsf > out.rsf coord=crd.rsf nw= kai=4.0 interp= | |||
file | coord= | auxiliary input file name | |
string | interp= | interpolation (lagrange,cubic,kaiser,lanczos,cosine,welch,spline) | |
float | kai=4.0 | Kaiser window parameter | |
int | nw= | interpolator size |
sfjacobi
Find eigenvalues of a symmetric matrix by Jacobi's iteration. | |||
---|---|---|---|
sfjacobi < mat.rsf > val.rsf eig=eig.rsf niter=10 | |||
string | eig= | auxiliary output file name | |
int | niter=10 |
sfjacobi2
Find eigenvalues of a general complex matrix by Jacobi-like iteration. | |||
---|---|---|---|
sfjacobi2 < mat.rsf > val.rsf niter=10 | |||
int | niter=10 |
sflapfill
Missing data interpolation in 2-D by Laplacian regularization. | |||
---|---|---|---|
sflapfill < in.rsf > out.rsf mask=mask.rsf niter=200 grad=n | |||
bool | grad=n | [y/n] | if y, use gradient instead of laplacian |
string | mask= | optional mask file with zeroes for missing data locations (auxiliary input file name) | |
int | niter=200 | number of iterations |
sflaplac
2-D finite-difference Laplacian operation. | |||
---|---|---|---|
sflaplac < in.rsf > out.rsf adj=n | |||
bool | adj=n | [y/n] | adjoint flag |
sflinear
1-D linear interpolation. | |||
---|---|---|---|
sflinear < in.rsf > out.rsf pattern=pattern.rsf sort=n niter=0 rect=1 nw=2 | |||
Specify either n1= o1= d1= or pattern= | |||
int | niter=0 | number of iterations | |
int | nw=2 | interpolator size | |
string | pattern= | auxiliary input file name | |
int | rect=1 | smoothing regularization | |
bool | sort=n | [y/n] | if y, the coordinates need sorting |
sflinefit
Fit a line to a set of points in 2-D. | |||
---|---|---|---|
sflinefit < in.rsf > out.rsf pattern=pattern.rsf | |||
string | pattern= | auxiliary input file name |
sflorenz
Generate Lorenz attractor. | |||
---|---|---|---|
sflorenz > out.rsf niter=1000 n=niter rho=28.00 sigma=10.00 beta=8.00/3.00 x0=3.051522 y0=1.582542 z0=15.62388 dt=0.0001 | |||
double | beta=8.00/3.00 | Beta reference | |
double | dt=0.0001 | time step | |
int | n=niter | set maximum | |
int | niter=1000 | number of iterations | |
double | rho=28.00 | Rayleigh number | |
double | sigma=10.00 | Prandtl number | |
double | x0=3.051522 | intial x coordinate | |
double | y0=1.582542 | intial y coordinate | |
double | z0=15.62388 | intial z coordinate |
sflpad
Pad and interleave traces. | |||
---|---|---|---|
sflpad < in.rsf > out.rsf mask=mask.rsf jump=2 | |||
Each initial trace is followed by I<jump> zero traces, the same for planes. | |||
int | jump=2 | aliasing | |
file | mask= | auxiliary output file name |
sfmandelbrot
Generate Mandelbrot set. | |||
---|---|---|---|
sfmandelbrot > out.rsf n1=512 n2=512 x0=-2. y0=-1. xmax=0.5 ymax=1. niter=1000 dx=(xmax-x0)/(n1-1) dy=(ymax-y0)/(n2-1) | |||
float | dx=(xmax-x0)/(n1-1) | ||
float | dy=(ymax-y0)/(n2-1) | ||
int | n1=512 | ||
int | n2=512 | dimensions | |
int | niter=1000 | number of iterations | |
float | x0=-2. | ||
float | xmax=0.5 | ||
float | y0=-1. | set origin | |
float | ymax=1. | set maximum |
sfmatmult
Simple matrix multiplication | |||
---|---|---|---|
sfmatmult < in.rsf > out.rsf mat=mat.rsf adj=n | |||
bool | adj=n | [y/n] | |
file | mat= | auxiliary input file name |
sfmax1
Picking local maxima on the first axis. | |||
---|---|---|---|
sfmax1 < in.rsf > out.rsf min=o1 max=o1+(n1-1)*d1 np=n1 | |||
Outputs complex numbers (time,amplitude) sorted by amplitude. | |||
float | max=o1+(n1-1)*d1 | maximum value of time | |
float | min=o1 | minimum value of time | |
int | np=n1 | maximum number of picks |
sfmiss2
2-D missing data interpolation. | |||
---|---|---|---|
sfmiss2 < in.rsf > out.rsf mask=mask.rsf niter=100 nliter=1 filt1=3. filt2=filt1 eps=0.0001 shape=n force=y | |||
float | eps=0.0001 | regularization parameter | |
float | filt1=3. | ||
float | filt2=filt1 | smoothing radius | |
bool | force=y | [y/n] | if y, keep known values |
string | mask= | optional input mask file for known data (auxiliary input file name) | |
int | niter=100 | Number of iterations | |
int | nliter=1 | Number of reweighting iterations | |
bool | shape=n | [y/n] | if y, estimate shaping |
sfmonof
Mono-frequency wavelet estimation. | |||
---|---|---|---|
sfmonof < in.rsf > out.rsf ma=ma.rsf a0=1. niter=100 verb=n | |||
float | a0=1. | starting sharpness | |
file | ma= | auxiliary output file name | |
int | niter=100 | number of iterations | |
bool | verb=n | [y/n] | verbosity flag |
sfmonof2
Gaussian wavelet estimation in 2-D. | |||
---|---|---|---|
sfmonof2 < in.rsf > out.rsf ma=ma.rsf a0=1. b0=0. c0=1. niter=100 nliter=1 verb=n | |||
float | a0=1. | starting sharpness in xx | |
float | b0=0. | starting sharpness in xy | |
float | c0=1. | starting sharpness in yy | |
file | ma= | auxiliary output file name | |
int | niter=100 | number of iterations | |
int | nliter=1 | number of reweighting iterations | |
bool | verb=n | [y/n] | verbosity flag |
sfmutter
Muting. | |||
---|---|---|---|
sfmutter < in.rsf > out.rsf offset=offset.rsf half=y nan=n tp=0.150 t0=0. v0=1.45 slope0=1./v0 slopep=slope0 x0=0. abs=y inner=n hyper=n | |||
Data is smoothly weighted inside the mute zone. The weight is zero for t < (x-x0) * slope0 The weight is one for t > tp + (x-x0) * slopep The signs are reversed for inner=y. | |||
bool | abs=y | [y/n] | x-x0| |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
bool | hyper=n | [y/n] | if y, do hyperbolic mute |
bool | inner=n | [y/n] | if y, do inner muter |
bool | nan=n | [y/n] | if y, put nans instead of zeros |
string | offset= | auxiliary input file name | |
float | slope0=1./v0 | slope | |
float | slopep=slope0 | end slope | |
float | t0=0. | starting time | |
float | tp=0.150 | end time | |
float | v0=1.45 | velocity | |
float | x0=0. | starting space |
sfnoise
Add random noise to the data. | |||
---|---|---|---|
sfnoise < in.rsf > out.rsf seed=time(NULL) type=y var= range= mean=0 rep=n | |||
July 2011 program of the month: http://ahay.org/rsflog/index.php?/archives/262-Program-of-the-month-sfnoise.html | |||
float | mean=0 | noise mean | |
float | range= | noise range (default=1) | |
bool | rep=n | [y/n] | if y, replace data with noise |
int | seed=time(NULL) | random seed | |
bool | type=y | [y/n] | noise distribution, y: normal, n: uniform |
float | var= | noise variance |
sfotsu
Compute a threshold value from histogram using Otsu's algorithm. | |||
---|---|---|---|
sfotsu < in.rsf |
sfpolymask
Mask a polygon. | |||
---|---|---|---|
sfpolymask < inp.rsf > out.rsf poly=poly.rsf | |||
file | poly= | auxiliary input file name |
sfpostfilter2
Convert B-spline coefficients to data in 2-D. | |||
---|---|---|---|
sfpostfilter2 < in.rsf > out.rsf nw= vert=y horz=y | |||
bool | horz=y | [y/n] | include filter on the second axis |
int | nw= | filter size | |
bool | vert=y | [y/n] | include filter on the first axis |
sfpow
Apply power gain. | |||
---|---|---|---|
sfpow < in.rsf > out.rsf tpow=0. pow#=(0,0,...) | |||
float | pow#=(0,0,...) | power on #-th axis | |
float | tpow=0. | power on the first axis |
sfreg2tri
Decimate a regular grid to triplets for triangulation. | |||
---|---|---|---|
sfreg2tri < in.rsf > out.rsf edgeout=edge.rsf nt= zero=0. | |||
string | edgeout= | auxiliary output file name | |
int | nt= | number of triplets | |
float | zero=0. | level surface |
sfremap1
1-D ENO interpolation. | |||
---|---|---|---|
sfremap1 < in.rsf > out.rsf pattern=pattern.rsf n1=n1 d1=d1 o1=o1 order=3 | |||
float | d1=d1 | Output sampling | |
int | n1=n1 | Number of output samples | |
float | o1=o1 | Output origin | |
int | order=3 | Interpolation order | |
string | pattern= | auxiliary input file name |
sfroots
Find roots of a complex polynomial. | |||
---|---|---|---|
sfroots < poly.rsf > root.rsf niter=10 tol=1.0e-6 verb=y sort= | |||
int | niter=10 | number of iterations | |
string | sort= | attribute for sorting | |
float | tol=1.0e-6 | tolerance for convergence | |
bool | verb=y | [y/n] | verbosity flag |
sfshapebin
Data binning in 2-D slices by inverse interpolation. | |||
---|---|---|---|
sfshapebin < in.rsf > out.rsf pattern=pattern.rsf pin=pin.rsf pout=pout.rsf xkey= ykey= nx= ny= xmin= xmax= ymin= ymax= x0=xmin y0=ymin dx= dy= interp=2 niter=nm nliter=1 eps=1./nd gauss=n shape=y verb=y filt1=3. filt2=filt1 head= | |||
float | dx= | bin size in x | |
float | dy= | bin size in y | |
float | eps=1./nd | regularization parameter | |
float | filt1=3. | ||
float | filt2=filt1 | smoothing length for shaping | |
bool | gauss=n | [y/n] | if y, use gaussian shaping (estimated from the data) |
string | head= | ||
int | interp=2 | interpolation length | |
int | niter=nm | number of iterations | |
int | nliter=1 | number of reweighting iterations | |
int | nx= | Number of bins in x | |
int | ny= | Number of bins in y | |
string | pattern= | auxiliary input file name | |
string | pin= | auxiliary input file name | |
string | pout= | auxiliary output file name | |
bool | shape=y | [y/n] | if y, use shaping regularization |
bool | verb=y | [y/n] | verbosity flag |
float | x0=xmin | ||
int | xkey= | x key number | |
float | xmax= | ||
float | xmin= | ||
float | y0=ymin | grid origin | |
int | ykey= | y key number | |
float | ymax= | ||
float | ymin= | Grid dimensions |
sfshapebin1
1-D inverse interpolation with shaping regularization. | |||
---|---|---|---|
sfshapebin1 < in.rsf > out.rsf verb=y nx= xmin= xmax= x0=xmin dx= interp=2 filter=3. niter=nx eps=1./nd pef=n gauss=n pad=0 head= | |||
float | dx= | grid sampling | |
float | eps=1./nd | regularization parameter | |
float | filter=3. | smoothing length | |
bool | gauss=n | [y/n] | if y, use Gaussian shaping |
string | head= | ||
int | interp=2 | [1,2] | forward interpolation method, 1: nearest neighbor, 2: linear |
int | niter=nx | number of conjugate-gradient iterations | |
int | nx= | number of bins | |
int | pad=0 | padding for Gaussian shaping | |
bool | pef=n | [y/n] | if y, use monofrequency regularization |
bool | verb=y | [y/n] | verbosity flag |
float | x0=xmin | grid origin | |
float | xmax= | ||
float | xmin= | grid size |
sfsharpen
Sharpening operator | |||
---|---|---|---|
sfsharpen < in.rsf > out.rsf other=other.rsf perc=50.0 | |||
string | other= | auxiliary input file name | |
float | perc=50.0 | percentage for sharpening |
sfslice
Extract a slice using picked surface (usually from a stack or a semblance). | |||
---|---|---|---|
sfslice < in.rsf pick=pick.rsf > out.rsf | |||
See also: sfpick. | |||
file | pick= | auxiliary input file name |
sfsmooth
Multi-dimensional triangle smoothing. | |||
---|---|---|---|
sfsmooth < in.rsf > out.rsf repeat=1 adj=n rect#=(1,1,...) diff#=(n,n,...) | |||
January 2012 program of the month: http://ahay.org/rsflog/index.php?/archives/280-Program-of-the-month-sfsmooth.html | |||
bool | adj=n | [y/n] | run in the adjoint mode |
bool | diff#=(n,n,...) | [y/n] | differentiation on #-th axis |
int | rect#=(1,1,...) | smoothing radius on #-th axis | |
int | repeat=1 | repeat filtering several times |
sfsmoothder
Smooth first derivative on the first axis. | |||
---|---|---|---|
sfsmoothder < in.rsf > der.rsf eps=0.2 | |||
Applies D/(I + eps*D'D) | |||
float | eps=0.2 | smoothness parameter |
sfsmoothreg2
Smoothing in 2-D by simple regularization. | |||
---|---|---|---|
sfsmoothreg2 < in.rsf > smooth.rsf eps=1. repeat=1 | |||
float | eps=1. | smoothness parameter | |
int | repeat=1 | repeat smoothing |
sfspectra
Frequency spectra. | |||
---|---|---|---|
sfspectra < in.rsf > out.rsf all=n opt=y | |||
March 2012 program of the month: http://ahay.org/rsflog/index.php?/archives/285-Program-of-the-month-sfspectra.html | |||
bool | all=n | [y/n] | if y, compute average spectrum for all traces |
bool | opt=y | [y/n] | if y, determine optimal size for efficiency |
sfspectra2
Frequency spectra in 2-D. | |||
---|---|---|---|
sfspectra2 < in.rsf > out.rsf all=n | |||
bool | all=n | [y/n] | if y, compute average spectrum for all traces |
sfspline
1-D cubic spline interpolation. | |||
---|---|---|---|
sfspline < in.rsf > out.rsf pattern=pattern.rsf fp= sort=n | |||
Specify either n1= o1= d1= or pattern= | |||
floats | fp= | end-point derivatives [2] | |
string | pattern= | auxiliary input file name | |
bool | sort=n | [y/n] | if y, the coordinates need sorting |
sfsplinefilter
Convert data to B-spline coefficients. | |||
---|---|---|---|
sfsplinefilter < in.rsf > out.rsf nw= | |||
int | nw= | filter size |
sfswtdenoise
Denoising using stationary wavelet transform. | |||
---|---|---|---|
sfswtdenoise < in.rsf > out.rsf ratio=1. len_filter=2 n_layer=2 | |||
int | len_filter=2 | filter length | |
int | n_layer=2 | number of wavelet transform layers | |
float | ratio=1. | ratio for denoising |
sfthreshold
Soft thresholding. | |||
---|---|---|---|
sfthreshold < in.rsf > out.rsf pclip= | |||
float | pclip= | percentage to clip |
sftrapez
Convolution with a trapezoidal filter. | |||
---|---|---|---|
sftrapez < in.rsf > out.rsf frequency= | |||
floats | frequency= | frequencies (in Hz), default: (0.1,0.15,0.45,0.5)*Nyquist [4] |
sftri2reg
Interpolate triangulated triplets to a regular grid. | |||
---|---|---|---|
sftri2reg < in.rsf > out.rsf pattern=pattern.rsf edgein=edge.rsf nodeout=out2.rsf edgeout=edge2.rsf n1= n2= d1=1. d2=1. o1=0. o2=0. zero=0. nr=0 | |||
float | d1=1. | ||
float | d2=1. | ||
string | edgein= | input edge file (auxiliary input file name) | |
string | edgeout= | auxiliary output file name | |
int | n1= | ||
int | n2= | ||
string | nodeout= | auxiliary output file name | |
int | nr=0 | number of refinements | |
float | o1=0. | ||
float | o2=0. | ||
string | pattern= | pattern file for output dimensions (auxiliary input file name) | |
float | zero=0. | level surface |
sftrirand
Edit points for triangulation by removing similar and randomizing. | |||
---|---|---|---|
sftrirand < in.rsf > out.rsf |
sftrishape
2-D irregular data interpolation using triangulation and shaping regularization. | |||
---|---|---|---|
sftrishape < in.rsf > out.rsf pattern=pattern.rsf n1= n2= d1=1. d2=1. o1=0. o2=0. zero=0. niter=0 rect1=1 rect2=1 nw=2 | |||
float | d1=1. | ||
float | d2=1. | ||
int | n1= | ||
int | n2= | ||
int | niter=0 | number of iterations | |
int | nw=2 | interpolator size | |
float | o1=0. | ||
float | o2=0. | ||
string | pattern= | pattern file for output dimensions (auxiliary input file name) | |
int | rect1=1 | ||
int | rect2=1 | smoothing regularization | |
float | zero=0. | level surface |
sfunif2
Generate 2-D layered velocity model from specified interfaces. | |||
---|---|---|---|
sfunif2 < surface.rsf > model.rsf x0= z0= v00= dvdx= dvdz= n1= d1= o1=0. label1= unit1= | |||
In each layer, velocity is a linear function of position. Inspired by SU's unif2. | |||
float | d1= | Sampling of the depth axis | |
floats | dvdx= | [ninf] | |
floats | dvdz= | [ninf] | |
string | label1= | depth axis label | |
int | n1= | Number of samples on the depth axis | |
float | o1=0. | Origin of the depth axis | |
string | unit1= | ||
floats | v00= | [ninf] | |
floats | x0= | [ninf] | |
floats | z0= | [ninf] |
sfunif3
Generate 3-D layered velocity model from specified interfaces. | |||
---|---|---|---|
sfunif3 < surface.rsf > model.rsf x0= y0= z0= v00= dvdx= dvdy= dvdz= n1= d1= o1=0. layers= | |||
Unless layers= is specified, velocity is a linear function of position inside each layer. Inspired by SU's unif2. | |||
float | d1= | Sampling of the depth axis | |
floats | dvdx= | [ninf] | |
floats | dvdy= | [ninf] | |
floats | dvdz= | [ninf] | |
string | layers= | file with layer properties | |
int | n1= | Number of samples on the depth axis | |
float | o1=0. | Origin of the depth axis | |
floats | v00= | [ninf] | |
floats | x0= | [ninf] | |
floats | y0= | [ninf] | |
floats | z0= | [ninf] |