void sf_banded_const_define (sf_bands slv,
float diag /* diagonal */,
const float* offd /* off-diagonal [band] */)
/*< define matrix with constant diagonal coefficients >*/
{
int k, m, m1, n, n1;
float t;
for (k = 0; k < slv->n; k++) {
t = diag;
m1 = SF_MIN(k,slv->band);
for (m = 0; m < m1; m++)
t -= (slv->o[m][k-m-1])*(slv->o[m][k-m-1])*(slv->d[k-m-1]);
slv->d[k] = t;
n1 = SF_MIN(slv->n-k-1,slv->band);
for (n = 0; n < n1; n++) {
t = offd[n];
m1 = SF_MIN(k,slv->band-n-1);
for (m = 0; m < m1; m++) {
t -= (slv->o[m][k-m-1])*(slv->o[n+m+1][k-m-1])*(slv->d[k-m-1]);
}
slv->o[n][k] = t/slv->d[k];
}
}
}
void sf_banded_define (sf_bands slv,
float* diag /* diagonal [n] */,
float** offd /* off-diagonal [band][n] */)
/*< define the matrix >*/
{
int k, m, m1, n, n1;
float t;
for (k = 0; k < slv->n; k++) {
t = diag[k];
m1 = SF_MIN(k,slv->band);
for (m = 0; m < m1; m++)
t -= (slv->o[m][k-m-1])*(slv->o[m][k-m-1])*(slv->d[k-m-1]);
slv->d[k] = t;
n1 = SF_MIN(slv->n-k-1,slv->band);
for (n = 0; n < n1; n++) {
t = offd[n][k];
m1 = SF_MIN(k,slv->band-n-1);
for (m = 0; m < m1; m++) {
t -= (slv->o[m][k-m-1])*(slv->o[n+m+1][k-m-1])*(slv->d[k-m-1]);
}
slv->o[n][k] = t/slv->d[k];
}
}
}
void sf_banded_const_define_eps (sf_bands slv,
float diag /* diagonal */,
const float* offd /* off-diagonal [band] */,
int nb /* size of the boundary */,
float eps /* regularization parameter */)
/*< define matrix with constant diagonal coefficients
and regularized b.c. >*/
{
int k, m, m1, n, n1;
float t;
for (k = 0; k < slv->n; k++) {
t = diag;
if (k < nb || slv->n-k-1 < nb) t += eps;
m1 = SF_MIN(k,slv->band);
for (m = 0; m < m1; m++)
t -= (slv->o[m][k-m-1])*(slv->o[m][k-m-1])*(slv->d[k-m-1]);
slv->d[k] = t;
n1 = SF_MIN(slv->n-k-1,slv->band);
for (n = 0; n < n1; n++) {
t = offd[n];
m1 = SF_MIN(k,slv->band-n-1);
for (m = 0; m < m1; m++) {
t -= (slv->o[m][k-m-1])*(slv->o[n+m+1][k-m-1])*(slv->d[k-m-1]);
}
slv->o[n][k] = t/slv->d[k];
}
}
}
static float linterp2(float x,float t)
{
float ans,st0,st1;
int i,k;
i=SF_MAX(0,SF_MIN(nx1-1,floor(x/hx)));
k=SF_MAX(0,SF_MIN(nt1-1,floor(t/ht)));
if( k<nt1 ) {
st0=linterp1(i,k,x);
st1=linterp1(i,k+1,x);
ans=linterp(st0,st1,ht,t);
}
else ans=linterp1(i,k,x);
return ans;
}
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);
}
static int
vorbis_command (SF_PRIVATE *psf, int command, void * data, int datasize)
{ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
switch (command)
{ case SFC_SET_COMPRESSION_LEVEL :
if (data == NULL || datasize != sizeof (double))
return SF_FALSE ;
if (psf->have_written)
return SF_FALSE ;
vdata->quality = 1.0 - *((double *) data) ;
/* Clip range. */
vdata->quality = SF_MAX (0.0, SF_MIN (1.0, vdata->quality)) ;
psf_log_printf (psf, "%s : Setting SFC_SET_VBR_ENCODING_QUALITY to %f.\n", __func__, vdata->quality) ;
return SF_TRUE ;
default :
return SF_FALSE ;
} ;
return SF_FALSE ;
} /* vorbis_command */
int main(void)
{
int i, j, i1, nf=8, n1=101, n2=301, im;
float *a, *a1, *a2, *w, f; /* a is reference data, a1 is true data, a2 is interpolated data. */
a=sf_floatalloc(n1);
a1=sf_floatalloc(n2);
a2=sf_floatalloc(n2);
w=sf_floatalloc(nf);
for(i=0;i<n1;i++)
a[i]=sinf(SF_PI/100*i)+cosf(SF_PI/100*i); /* Calculate original data point value. */
for(i=0;i<n2;i++)
a1[i]=sinf(SF_PI/100*(0+1.0/3*i))+cosf(SF_PI/100*(0+1.0/3*i)); /* Calculate true fine-grid data point value. */
for(i1=0;i1<n2;i1++)
{
f=(1.0-0.5*nf)+(0+1.0/3*i1-0)/1;
j=f; /* j is grid location */
f-=j; /* f is offset from grid location */
sf_spline_int(f,nf,w);
a2[i1]=0;
for (i = SF_MAX(0,-j); i < SF_MIN(nf,n1-j); i++) {
im = i+j;
a2[i1]+=a[im]*w[i];
}
}
for(i=0;i<n2;i++)
sf_warning("Interpolation result comparison: True[%d]=%f, Inter[%d]=%f",i,a1[i],i,a2[i]);
exit(0);
}
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;
}
}
static int
ogg_command (SF_PRIVATE *psf, int command, void * data, int datasize)
{ VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
switch (command)
{ case SFC_SET_VBR_ENCODING_QUALITY :
if (data == NULL || datasize != sizeof (double))
return 1 ;
if (psf->have_written)
return 1 ;
vdata->quality = *((double *) data) ;
/* Clip range. */
vdata->quality = SF_MAX (0.0, SF_MIN (1.0, vdata->quality)) ;
psf_log_printf (psf, "%s : Setting SFC_SET_VBR_ENCODING_QUALITY to %f.\n", __func__, vdata->quality) ;
break ;
default :
return 0 ;
} ;
return 0 ;
} /* ogg_command */
void stretch4_invert (bool add /* add flag */,
map4 str,
float* ord /* [nd] */,
float* mod /* [n1] */)
/*< convert model to ordinates by spline interpolation >*/
{
int id, it, i, nt, i1, i2;
float *w, *mm;
sf_adjnull(false,add,str->nt,str->nd,mod,ord);
mm = str->diag;
nt = str->nt;
for (it = 0; it < nt; it++) {
mm[it] = mod[it];
}
sf_tridiagonal_solve(str->tslv, mm);
for (id = 0; id < str->nd; id++) {
if (str->m[id]) continue;
it = str->x[id];
w = str->w[id];
i1 = SF_MAX(0,-it);
i2 = SF_MIN(4,nt-it);
for (i=i1; i < i2; i++) {
ord[id] += w[i]*mm[it+i];
}
}
}
/*------------------------------------------------------------*/
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 int
caf_read_chanmap (SF_PRIVATE * psf, sf_count_t chunk_size)
{ const AIFF_CAF_CHANNEL_MAP * map_info ;
unsigned channel_bitmap, channel_decriptions, bytesread ;
int layout_tag ;
bytesread = psf_binheader_readf (psf, "E444", &layout_tag, &channel_bitmap, &channel_decriptions) ;
map_info = aiff_caf_of_channel_layout_tag (layout_tag) ;
psf_log_printf (psf, " Tag : %x\n", layout_tag) ;
if (map_info)
psf_log_printf (psf, " Layout : %s\n", map_info->name) ;
if (bytesread < chunk_size)
psf_binheader_readf (psf, "j", chunk_size - bytesread) ;
if (map_info && map_info->channel_map != NULL)
{ size_t chanmap_size = SF_MIN (psf->sf.channels, layout_tag & 0xff) * sizeof (psf->channel_map [0]) ;
free (psf->channel_map) ;
if ((psf->channel_map = malloc (chanmap_size)) == NULL)
return SFE_MALLOC_FAILED ;
memcpy (psf->channel_map, map_info->channel_map, chanmap_size) ;
} ;
return 0 ;
} /* caf_read_chanmap */
/*------------------------------------------------------------*/
float hwt3d_getv(float ***vv,
pt3d P)
/*< get velocity from 3-D cube by linear interpolation >*/
{
double z, x, y;
double rz,rx,ry;
int jz,jx,jy;
double fz,fx,fy;
float v;
int kz,kx,ky;
x = SF_MIN(SF_MAX(ax.o,P.x),ax.o+(ax.n-2)*ax.d);
y = SF_MIN(SF_MAX(ay.o,P.y),ay.o+(ay.n-2)*ay.d);
z = SF_MIN(SF_MAX(az.o,P.z),az.o+(az.n-2)*az.d);
rx = (x-ax.o)/ax.d;
jx = (int)(rx);
fx = rx-jx;
kx = jx+1;
ry = (y-ay.o)/ay.d;
jy = (int)(ry);
fy = ry-jy;
ky = jy+1;
rz = (z-az.o)/az.d;
jz = (int)(rz);
fz = rz-jz;
kz = jz+1;
if(ax.n==1) {jx=0; kx=0; fx=0;}
if(ay.n==1) {jy=0; ky=0; fy=0;}
if(az.n==1) {jz=0; kz=0; fz=0;}
v = vv[ jy][ jx][ jz] * (1-fz)*(1-fx)*(1-fy) +
vv[ jy][ jx][ kz] * ( fz)*(1-fx)*(1-fy) +
vv[ ky][ jx][ jz] * (1-fz)*(1-fx)*( fy) +
vv[ ky][ jx][ kz] * ( fz)*(1-fx)*( fy) +
vv[ jy][ kx][ jz] * (1-fz)*( fx)*(1-fy) +
vv[ jy][ kx][ kz] * ( fz)*( fx)*(1-fy) +
vv[ ky][ kx][ jz] * (1-fz)*( fx)*( fy) +
vv[ ky][ kx][ kz] * ( fz)*( fx)*( fy);
return(v);
}
static char solve2pt(int ind,int inda,int indb,float ha,float hb,char ch)
{
int kmin /* ,i,k ,i1,k1 */;
float x1,x2;
float xa,ta,xb,tb,x,t,tmin;
float d,dp,dp2,df;
char /* ch1='y', */ ch2='n';
int ntry=0;
xa=*(x0+inda);
ta=*(t0+inda);
xb=*(x0+indb);
tb=*(t0+indb);
tmin=SF_MAX(ta,tb)-TOL;
kmin=floor(tmin/ht);
x1=SF_MIN(xa,xb)-TOL;
x2=SF_MAX(xa,xb)+TOL;
t=*(t0+ind);
if( kmin<nt1 ) {
while( ch2=='n' && ntry<NTRYMAX ) {
x=lateral(t,xa,xb,ta,tb,ha,hb);
/*i=SF_MAX(0,SF_MIN(nx1-1,floor(x/hx)));
k=SF_MAX(0,SF_MIN(nt1-1,floor(t/ht))); */
d=fn(t,ta,tb,xa,xb,ha,hb);
dp=2.0*d;
dp2=dp;
while( fabs(d)>TOL && fabs(dp2)>fabs(d) ) {
df=dfn(t,ta,tb,xa,xb,ha,hb);
t-=d/df;
dp2=dp;
dp=d;
d=fn(t,ta,tb,xa,xb,ha,hb);
}
x=lateral(t,xa,xb,ta,tb,ha,hb);
/* i1=SF_MAX(0,SF_MIN(nx1-1,floor(x/hx)));
k1=SF_MAX(0,SF_MIN(nt1-1,floor(t/ht))); */
if( x>=x1 && x<=x2 && t>=tmin ) ch2='y';
ntry++;
}
if( fabs(d)<=TOL && t>=tmin ) {
if( x>=x1 && x<=x2 ) {
/* ch1='n'; */
if( *(pup+ind)<=1 || (*(pup+ind)==2 && t<(*(t0+ind))) ) {
ch='s';
*(t0+ind)=t;
*(x0+ind)=x;
*(pup+ind)=2;
*(v+ind)=1.0/linterp2(x,t);
}
ch=(ch=='s') ? 's' : 'n';
}
}
}
else
ch=(ch=='s') ? 's' : 'f';
return ch;
}
void sf_pweno_apply (sf_pweno ent,
int i /* grid location */,
float x /* offset from grid */,
float *f /* output data value */,
float *f1 /* output derivative */,
derr what /* flag of what to compute */)
/*< Apply interpolation >*/
{
int j, k, i1, i2, n;
float s, s1, y, w, g, g1, tw;
/* Stencil */
i2 = SF_MAX(0,SF_MIN(i,ent->n-ent->order));
i1 = SF_MIN(i2,SF_MAX(0,i-ent->order+2));
/* ENO selection */
w = fabsf(ent->diff[ent->order-1][i1]);
for (j=i1+1; j <=i2; j++) {
g = ((j != i) ? fabsf(ent->diff[ent->order-1][j]) : fabsf(ent->diff[ent->order][i]) );
if (w > g) w = g;
}
/* Loop over starting points */
for (g = 0., g1 = 0., n = 0, j = i1; j <= i2; j++) {
tw = ((j != i) ? ent->diff[ent->order-1][j] : ent->diff[ent->order][i] );
if (fabsf(tw) > w) continue;
n++;
y = x + i - j;
/* Loop to compute the polynomial */
for (s = 1., s1 = 0., k=0; k < ent->order; k++) {
if (what != FUNC1) {
g1 += s1*ent->diff[k][j];
s1 = (s + s1*(y-k))/(k+1.);
}
if (what != DER1) g += s*((k != (ent->order-1) || j != i) ? ent->diff[k][j] : ent->diff[ent->order][i] );
s *= (y-k)/(k+1.);
}
}
if (what != DER1) *f = g/n;
if (what != FUNC1) *f1 = g1/n;
}
void shot_rotate_get_bx_ex_iz(float *dkx,int *bx,int *ex, int iz,int boundary_nx, struct shot_rotate_par_type rotate_par)
/*< rotate >*/
{
float dx,dz,rotate_angle;
int nx,nz,nx_rotate,nz_rotate,ix_rotate_center;
int nz_left,nz_right;
int tmp_nx,nx_iz;
float x,z,tan_rotate_angle;
dx=rotate_par.dx; dz=rotate_par.dz; nx=rotate_par.nx; nz=rotate_par.nz; rotate_angle=rotate_par.rotate_angle;
nx_rotate=rotate_par.nx_rotate; nz_rotate=rotate_par.nz_rotate; ix_rotate_center=rotate_par.ix_rotate_center;
nz_left=rotate_par.nz_left; nz_right=rotate_par.nz_right;
tan_rotate_angle=sin(fabs(rotate_angle))/cos(fabs(rotate_angle));
if (iz < nz_left) {
z=(float)(iz)*dz;
x=z*tan_rotate_angle;
tmp_nx=(int)(x/dx)+boundary_nx;
*bx=SF_MAX(0,ix_rotate_center-tmp_nx);
}
else{
z=(float)(iz-nz_left)*dz; x=z/tan_rotate_angle;
tmp_nx=(int)(x/dx)-boundary_nx;
*bx=SF_MAX(0,tmp_nx);
}
if (iz <nz_right){
z=(float)(iz)*dz; x=z/tan_rotate_angle;
tmp_nx=(int)(x/dx)+boundary_nx;
*ex=SF_MIN(nx_rotate-1,ix_rotate_center+tmp_nx);
}
else{
z=(float)(iz-nz_right)*dz; x=z*tan_rotate_angle;
tmp_nx=(int)(x/dx)-boundary_nx;
*ex=SF_MIN(nx_rotate-1,nx_rotate-tmp_nx);
}
nx_iz=kissfftn(*ex-*bx+1); *ex=*bx+nx_iz-1;
if ( *ex > nx_rotate-1 ){
//*bx=0; *ex=nx_rotate-1; nx_iz=nx_rotate;
*ex=nx_rotate-1; *bx=*ex+1-nx_iz;
if (*bx<0){*ex=nx_rotate-1; *bx=0; nx_iz=nx_rotate;}
}
*dkx=2.0*SF_PI/((float)(nx_iz)*dx);
}
void stretch4_apply (bool add /* add flag */,
map4 str,
float* ord /* [nd] */,
float* mod /* [n1] */)
/*< transform ordinates to model >*/
{
int id, it, i, nt, i1, i2;
float *w, *mm, *mod2;
sf_adjnull(false,add,str->nd,str->nt,ord,mod);
mm = str->diag;
nt = str->nt;
mod2 = sf_floatalloc(nt);
for (it = 0; it < nt; it++) {
mm[it] = 0.0f;
}
for (id = 0; id < str->nd; id++) {
if (str->m[id]) continue;
it = str->x[id];
w = str->w[id];
i1 = SF_MAX(0,-it);
i2 = SF_MIN(4,nt-it);
for (i=i1; i < i2; i++) {
mm[it+i] += w[i]*ord[id];
}
}
sf_banded_solve (str->slv, mm);
for (it = 0; it <= str->ib; it++) {
mm[it] = 0.0f;
}
for (it = str->ie; it < nt; it++) {
mm[it] = 0.0f;
}
sf_spline4_post(nt,0,nt,mm,mod2);
for (it=0; it < nt; it++) {
if (it > str->ib && it < str->ie) {
mod[it] += mod2[it];
}
}
free(mod2);
}
void stretch4_apply_adj (bool add, /* add flag */
map4 str,
float* ord /* [nd] */,
float* mod /* [n1] */)
/*< transform model to ordinates by adjoint operation >*/
{
int id, it, i, nt, i1, i2;
float *w, *mm, *mod2;
sf_adjnull(true,add,str->nd,str->nt,ord,mod);
mm = str->diag;
nt = str->nt;
mod2 = sf_floatalloc(nt);
for (it = 0; it <= nt; it++) {
mod2[it] = mod[it];
}
for (it = 0; it <= str->ib; it++) {
mod2[it] = 0.0f;
}
for (it = str->ie; it < nt; it++) {
mod2[it] = 0.0f;
}
sf_spline4_post(nt,0,nt,mod2,mm);
for (it = 0; it <= str->ib; it++) {
mm[it] = 0.0f;
}
for (it = str->ie; it < nt; it++) {
mm[it] = 0.0f;
}
sf_banded_solve (str->slv, mm);
for (id = 0; id < str->nd; id++) {
if (str->m[id]) continue;
it = str->x[id];
w = str->w[id];
i1 = SF_MAX(0,-it);
i2 = SF_MIN(4,nt-it);
for (i=i1; i < i2; i++) {
ord[id] += w[i]*mm[it+i];
}
}
}
void sf_banded_solve (const sf_bands slv, float* b)
/*< invert (in place) >*/
{
int k, m, m1;
float t;
for (k = 1; k < slv->n; k++) {
t = b[k];
m1 = SF_MIN(k,slv->band);
for (m = 0; m < m1; m++)
t -= (slv->o[m][k-m-1]) * b[k-m-1];
b[k] = t;
}
for (k = slv->n-1; k >= 0; k--) {
t = b[k]/slv->d[k];
m1 = SF_MIN(slv->n -k-1,slv->band);
for (m = 0; m < m1; m++)
t -= slv->o[m][k] * b[k+m+1];
b[k] = t;
}
}
void shot_image_stack(float *img,float mig_min_x,float mig_min_y,int mig_nx,int mig_ny,sf_file tag,
struct shot_image_par_type image_par)
/*< stack image >*/
{
float *tmp_img;
float img_min_x,img_max_x,img_min_y,img_max_y,img_dx,img_dy;
float mig_max_x,rite_min_x,rite_max_x;
int img_ny,img_nx,rite_nx;
int n_hy_hx,img_nhx,img_nhy,nz;
int ntmp_img[2],nimg[3];
int rite_ix_b,array_ix_b;
int block_size,block_i;
int iy,rite_iy,ix,i_hy_hx,iz;
img_min_x=image_par.min_x; img_max_x=image_par.max_x; img_min_y=image_par.min_y; img_max_y=image_par.max_y;
img_dx=image_par.dx; img_dy=image_par.dy; img_ny=image_par.ny; img_nx=image_par.nx;
img_nhx=image_par.nhx; img_nhy=image_par.nhy; nz=image_par.nz;
mig_max_x=((float)(mig_nx-1))*img_dx+mig_min_x;
rite_min_x=SF_MAX(img_min_x,mig_min_x);
rite_max_x=SF_MIN(img_max_x,mig_max_x);
rite_nx=(rite_max_x-rite_min_x)/img_dx+1;
n_hy_hx= img_nhy*img_nhx; d3(n_hy_hx,nz,ntmp_img); d4(mig_ny,mig_nx,n_hy_hx,nimg);
if (rite_nx >=1){
rite_ix_b= (rite_min_x-img_min_x)/img_dx;
array_ix_b=(rite_min_x-mig_min_x)/img_dx;
tmp_img=sf_floatalloc(rite_nx*n_hy_hx*nz);
block_size=4*n_hy_hx*nz;
for(iy=0;iy<mig_ny;iy++){
vector_value_f(tmp_img,0.0,rite_nx*n_hy_hx*nz);
rite_iy= iy+(mig_min_y-img_min_y)/img_dy;
if (rite_iy < img_ny && rite_iy>= 0){
block_i=rite_iy*img_nx+rite_ix_b;
sf_seek(tag,block_i*block_size,SEEK_SET);
sf_floatread(tmp_img,rite_nx*n_hy_hx*nz,tag);
for(ix=0;ix<rite_nx;ix++){
for(i_hy_hx=0;i_hy_hx<n_hy_hx;i_hy_hx++){
for(iz=0;iz<nz;iz++){
tmp_img[i3(ix,i_hy_hx,iz,ntmp_img)]+=img[i4(iz,iy,array_ix_b+ix,i_hy_hx,nimg)];
}
}
}
sf_seek(tag,block_i*block_size,SEEK_SET);
sf_floatwrite(tmp_img,rite_nx*n_hy_hx*nz,tag);
}
}
free(tmp_img);
}
}
int
broadcast_var_get (SF_PRIVATE *psf, SF_BROADCAST_INFO * data, size_t datasize)
{ size_t size ;
if (psf->broadcast_var == NULL)
return SF_FALSE ;
size = SF_MIN (datasize, bc_min_size (&(psf->broadcast_var->binfo))) ;
memcpy (data, &(psf->broadcast_var->binfo), size) ;
return SF_TRUE ;
} /* broadcast_var_set */
int
broadcast_var_get (SF_PRIVATE *psf, SF_BROADCAST_INFO * data, size_t datasize)
{ size_t size ;
if (psf->broadcast_16k == NULL)
return SF_FALSE ;
size = SF_MIN (datasize, bc_min_size ((const SF_BROADCAST_INFO *) psf->broadcast_16k)) ;
memcpy (data, psf->broadcast_16k, size) ;
return SF_TRUE ;
} /* broadcast_var_get */
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);
}
float sf_esc_tracer3_sintersect (sf_esc_tracer3 esc_tracer, float *z, float *x, float *y,
float *b, float *a, float dz, float dx, float dy,
float db, float da, float fz, float fx, float fy,
float fb, float fa)
/*< Compute intersection of a straight trajectory from (z, x, y, b, a) with
the nearest wall defined by (dz, dx, dy, db, da), return pseudotime along the trajectory >*/
{
float tz, tx, ty, tb, ta, sigma, rp = 1e-6;
/* Loop until curvature approximation by a straight line is adequate */
do {
/* Time to phase-space cell walls */
tz = fabsf (fz) > rp ? fabsf (dz/fz) : SF_HUGE;
tx = fabsf (fx) > rp ? fabsf (dx/fx) : SF_HUGE;
ty = fabsf (fy) > rp ? fabsf (dy/fy) : SF_HUGE;
tb = fabsf (fb) > rp ? fabsf (db/fb) : SF_HUGE;
ta = fabsf (fa) > rp ? fabsf (da/fa) : SF_HUGE;
/* Hitting the angle wall first - too much curvature on the ray,
reduce distance by half */
if ((ta < tz && ta < tx && ta < ty) ||
(tb < tz && tb < tx && tb < ty)) {
dz *= 0.5;
dx *= 0.5;
dy *= 0.5;
}
} while ((ta < tz && ta < tx && ta < ty) ||
(tb < tz && tb < tx && tb < ty));
sigma = SF_MIN (ta, tb);
sigma = SF_MIN (ty, sigma);
sigma = SF_MIN (tx, sigma);
sigma = SF_MIN (tz, sigma);
*z -= fz*sigma;
*x -= fx*sigma;
*y -= fy*sigma;
*b -= fb*sigma;
*a -= fa*sigma;
return sigma;
}
void dynprog(int i0 /* starting velocity */,
float** weight /* [n1][n2] */)
/*< apply >*/
{
float d, c, w, w2;
int i1, i2, i, ic, ib, ie, it;
if (NULL != ttime) {
for (i2=0; i2 < n2; i2++) {
w = 0.5*(weight[0][i2]+weight[0][i0]);
ttime[0][i2] = SF_ABS(i2-i0)*w;
}
}
for (i2=0; i2 < n2; i2++) {
w = 0.5*(weight[1][i2]+weight[0][i0]);
prev[i2] = dist[SF_ABS(i2-i0)]*w;
what[1][i2] = i0;
if (NULL != ttime) ttime[1][i2]=prev[i2];
}
for (i1=2; i1 < n1; i1++) {
for (i2=0; i2 < n2; i2++) {
w = weight[i1][i2];
ib = SF_MAX(i2-gt,-1);
ie = SF_MIN(i2+gt,n2);
c = FLT_MAX;
ic = -1;
for (i=ib+1; i < ie; i++) {
w2 = 0.5*(w+weight[i1-1][i]);
d = dist[SF_ABS(i2-i)]*w2+prev[i];
it = i-ib-1;
if (d < c) {
c = d;
ic = it;
}
prob[it]=d;
}
next[i2]=find_minimum(ic,ie-ib-1,ib+1,c,&what[i1][i2]);
}
for (i2=0; i2 < n2; i2++) {
prev[i2]=next[i2];
if (NULL != ttime) ttime[i1][i2]=prev[i2];
}
}
}
float cal_beta(const float *g0, const float *g1, const float *cg, int nz, int nx)
/*< calculate beta >*/
{
float a = 0;
float b = 0;
float c = 0;
for (int ix = 0; ix < nx; ix++) {
for (int iz = 0; iz < nz; iz++) {
int idx = ix * nz + iz;
a += g1[idx] * (g1[idx] - g0[idx]); // numerator of HS
b += cg[idx] * (g1[idx] - g0[idx]); // denominator of HS,DY
c += g1[idx] * g1[idx]; // numerator of DY
}
}
float beta_HS = (fabsf(b) > 0) ? (a / b) : 0.0;
float beta_DY = (fabsf(b) > 0) ? (c / b) : 0.0;
return SF_MAX(0.0, SF_MIN(beta_HS, beta_DY));
}
void sf_unpipe (sf_file file, off_t size)
/*< Redirect a pipe input to a direct access file >*/
{
off_t nbuf, len, bufsiz;
char *dataname=NULL;
FILE* tmp;
char *buf;
if (!(file->pipe)) return;
tmp = sf_tempfile(&dataname,"wb");
bufsiz = sf_bufsiz(file);
buf = sf_charalloc(SF_MIN(bufsiz,size));
while (size > 0) {
nbuf = (bufsiz < size)? bufsiz : size;
if (nbuf != fread(buf,1,nbuf,file->stream) ||
nbuf != fwrite(buf,1,nbuf,tmp))
sf_error ("%s: trouble unpiping:",__FILE__);
size -= nbuf;
}
free(buf);
if (NULL != file->dataname ) {
len = strlen(dataname)+1;
file->dataname = (char*) sf_realloc(file->dataname,len,sizeof(char));
memcpy(file->dataname,dataname,len);
}
/*
if (unlink(file->dataname))
sf_warning ("%s: trouble removing %s:",__FILE__,file->dataname);
*/
(void) fclose(file->stream);
file->stream = freopen(dataname,"rb",tmp);
if (NULL == file->stream)
sf_error ("%s: Trouble reading data file %s:",__FILE__,dataname);
}
/*------------------------------------------------------------*/
void hwt3d_fill(float*** tt, /* traveltime cube */
int n)
/*< fill holes >*/
{
int ix,iy,iz;
int kx,ky,kz;
int lx,ly,lz;
int jx,jy,jz;
float v;
int k;
for(iz=0;iz<az.n;iz++) {
for(iy=0;iy<ay.n;iy++) {
for(ix=0;ix<ax.n;ix++) {
/*---------------------------------------*/
if( tt[iy][ix][iz] == MISSING) {
kx=SF_MIN(SF_MAX(ix-n,0),ax.n-1);
ky=SF_MIN(SF_MAX(iy-n,0),ay.n-1);
kz=SF_MIN(SF_MAX(iz-n,0),az.n-1);
lx=SF_MIN(SF_MAX(ix+n,0),ax.n-1);
ly=SF_MIN(SF_MAX(iy+n,0),ay.n-1);
lz=SF_MIN(SF_MAX(iz+n,0),az.n-1);
k=0;
v=0.;
for(jz=kz;jz<=lz;jz++) {
for(jy=ky;jy<=ly;jy++) {
for(jx=kx;jx<=lx;jx++) {
if( tt[jy][jx][jz] != MISSING) {
v+=tt[jy][jx][jz];
k++;
}
}
}
} /* local loop */
if(k>0) tt[iy][ix][iz] = v/k;
} /* end if MISSING */
/*---------------------------------------*/
}
}
} /* global loop */
}
static int
caf_get_chunk_data (SF_PRIVATE *psf, const SF_CHUNK_ITERATOR * iterator, SF_CHUNK_INFO * chunk_info)
{ int indx ;
sf_count_t pos ;
if ((indx = psf_find_read_chunk_iterator (&psf->rchunks, iterator)) < 0)
return SFE_UNKNOWN_CHUNK ;
if (chunk_info->data == NULL)
return SFE_BAD_CHUNK_DATA_PTR ;
chunk_info->id_size = psf->rchunks.chunks [indx].id_size ;
memcpy (chunk_info->id, psf->rchunks.chunks [indx].id, sizeof (chunk_info->id) / sizeof (*chunk_info->id)) ;
pos = psf_ftell (psf) ;
psf_fseek (psf, psf->rchunks.chunks [indx].offset, SEEK_SET) ;
psf_fread (chunk_info->data, SF_MIN (chunk_info->datalen, psf->rchunks.chunks [indx].len), 1, psf) ;
psf_fseek (psf, pos, SEEK_SET) ;
return SFE_NO_ERROR ;
} /* caf_get_chunk_data */
void GreenTtAmp(float r1,float r2,float r3,float s1,float s2,float s3,double *tt,double *amp)
/*< traveltime-amplitude >*/
{
double x2,z1,z2,beta,xr;
double thetas,thetar;
if (vgrad < EPS) {
xr=sqrt((s1-r1)*(s1-r1) + (s2-r2)*(s2-r2) + (s3-r3)*(s3-r3));
*tt=xr/v0;
*amp=1./SF_MAX(xr,EPS);
} else {
x2=sqrt((s1-r1)*(s1-r1) + (s2-r2)*(s2-r2));
if (x2<EPS) {
*tt=fabs(r3-s3)/(0.5*s3*vgrad+0.5*r3*vgrad+v0);
*amp=1./((*tt)*v0);
return;
}
z1=SF_MIN(s3,r3); z1+=v0/vgrad;
z2=SF_MAX(s3,r3); z2+=v0/vgrad;
beta=0.5*(z1+z2)/x2;
xr=0.5*x2-beta*(z1-z2);
thetas=atan(z1/xr);
if (fabs(xr-x2)<EPS) thetar=SF_PI/2.;
else thetar=atan(z2/(xr-x2));
if (xr > x2)
*tt= (log(fabs(tan(thetar/2)))-log(fabs(tan(thetas/2))))/vgrad;
else if (xr < x2)
*tt=-(log(fabs(tan(thetar/2)))+log(fabs(tan(thetas/2))))/vgrad;
else
*tt=-(log(fabs(tan(thetas/2))));
*amp=1./(v0*SF_MAX(*tt,EPS));
}
return;
}
