int fgettra(FILE *fp, segy *tp, int itr)
{
int nread;
if(lastfp != fp) searchlist(fp); /* search for match */
if(infoptr == (struct insegyinfo *) NULL) {
/* get first trace */
if(0 >= fgettr(fp, tp)) return(0); /* error return */
switch(infoptr->ftype) {
case TTY:
warn("stdin not redirected");
break;
case DISK: /* correct */
break;
default:
err("%s: input must be disk file",__FILE__);
}
efseeko(fp,(off_t) 0LL,SEEK_END);
if( in_line_hdr ){
infoptr->ntr = (off_t)((eftello(fp)-3600)/infoptr->nsegy);
efseeko(fp, (off_t) 3600+infoptr->nsegy,SEEK_SET);
}else{
infoptr->ntr = (off_t)(eftello(fp)/infoptr->nsegy);
efseeko(fp, (off_t) infoptr->nsegy,SEEK_SET);
}
} /* end first entry initialization */
/* Check on requested trace number */
if(itr >= infoptr->ntr)
err("%s: trying to read off end of file",__FILE__);
/* Position file pointer at start of requested trace */
if( in_line_hdr ){
efseeko(fp, (off_t) 3600+itr*infoptr->nsegy,SEEK_SET);
}else{
efseeko(fp, (off_t) itr*infoptr->nsegy,SEEK_SET);
}
nread=fgettr(fp, tp); /* let fgettr do the work */
if(nread != infoptr->nsegy)
err("%s: read %d bytes in trace of %d bytes",
__FILE__,nread,infoptr->nsegy);
if(tp->ns != infoptr->nsfirst)
warn("%s: header ns field = %d differs from first trace = %d",
__FILE__,tp->ns,infoptr->nsfirst);
return(infoptr->ntr);
}
int
main (int argc, char **argv)
{
int n1,n2,i2;
float f1,f2,d1,d2,*x;
char *label2="Trace",label[256];
FILE *infp=stdin,*outfp=stdout;
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(0);
/* get optional parameters */
if (!getparint("n1",&n1)) {
if (efseeko(infp,(off_t) 0,SEEK_END)==-1)
err("input file size is unknown; specify n1!\n");
if ((n1=((int) (eftello(infp)/((off_t) sizeof(float)))))<=0)
err("input file size is unknown; specify n1!\n");
efseeko(infp,(off_t) 0,SEEK_SET);
}
if (!getparfloat("d1",&d1)) d1 = 1.0;
if (!getparfloat("f1",&f1)) f1 = d1;
if (!getparint("n2",&n2)) n2 = -1;
if (!getparfloat("d2",&d2)) d2 = 1.0;
if (!getparfloat("f2",&f2)) f2 = d2;
getparstring("label2",&label2);
/* allocate space */
x = ealloc1float(n1);
/* loop over 2nd dimension */
for (i2=0; i2<n2 || n2<0; i2++) {
/* read input array, watching for end of file */
if (efread(x,sizeof(float),n1,infp)!=n1) break;
/* make plot label */
sprintf(label,"%s %0.4g",label2,f2+i2*d2);
/* plot the array */
prp1d(outfp,label,n1,d1,f1,x);
}
return(CWP_Exit());
}
static
int fgettr_internal(FILE *fp, segy *tp, cwp_Bool fixed_length) {
int nread; /* bytes seen by fread calls */
unsigned char buf[240]; /* buffer for test for line header */
/* search linked list for possible alternative */
if(fp != lastfp) searchlist(fp);
if (infoptr == ((struct insegyinfo *) NULL)) {
/* initialize new segy input stream */
unsigned int databytes; /* bytes from nsfirst */
/* allocate new segy input information table */
*oldinfoptr = (struct insegyinfo *)
malloc(sizeof(struct insegyinfo));
infoptr = *oldinfoptr;
infoptr->nextinfo = (struct insegyinfo *) NULL;
infoptr->infp = fp; /* save FILE * ptr */
infoptr->itr = 0;
infoptr->ntr = -1;
switch (infoptr->ftype = filestat(fileno(fp))) {
case DIRECTORY:
err("%s: segy input can't be a directory", __FILE__);
case TTY:
err("%s: segy input can't be tty", __FILE__);
default:
/* all others are ok */
break;
}
/*--------------------------------------------------------------------*\
Check for the presence of a line header and set a flag if one is
found. The decision of what to do will be delayed until the call
to fputtr(). This allows us to accept data w/ or w/o a line
header.
Reginald H. Beardsley [email protected]
\*--------------------------------------------------------------------*/
/* Attempt to get a text header */
nread=efread(buf ,1 ,HDRBYTES ,infoptr->infp);
switch( nread ){
case 0:
return 0; /* no traces; trap in mains */
default:
if (nread < HDRBYTES ){
return 0;
}else if( isascii_txt( buf ,HDRBYTES )
|| isebcdic_txt( buf ,HDRBYTES ) ){
in_line_hdr = 1;
memcpy( su_text_hdr ,buf ,HDRBYTES );
nread += efread(&(su_text_hdr[HDRBYTES]) ,1
,3200-HDRBYTES ,infoptr->infp);
}else{
in_line_hdr=0;
memcpy( tp ,buf ,HDRBYTES );
}
}
if( in_line_hdr ){
/* Get the binary header */
nread = efread(&su_binary_hdr, 1, sizeof(bhed), infoptr->infp);
switch( nread ){
case 0:
return 0; /* no traces; trap in mains */
default:
if (nread != sizeof(su_binary_hdr)){
err("%s:%d bad binary header" , __FILE__ ,__LINE__ );
}
}
/* Get the first trace header */
nread = efread(tp, 1, HDRBYTES, infoptr->infp);
switch( nread ){
case 0:
return 0; /* no traces; trap in mains */
default:
if (nread != HDRBYTES){
err("%s: bad first header", __FILE__);
}
}
}
/* Have the header, now for the data */
infoptr->nsfirst = tp->ns;
if (infoptr->nsfirst > SU_NFLTS){
err("%s: unable to handle %d > %d samples per trace",
__FILE__, infoptr->nsfirst, SU_NFLTS);
}
switch (tp->trid) {
case CHARPACK:
infoptr->bytesper = sizeof(char); break;
case SHORTPACK:
infoptr->bytesper = 2*sizeof(char); break;
default:
infoptr->bytesper = sizeof(float); break;
}
databytes = infoptr->bytesper * tp->ns;
infoptr->nsegy = HDRBYTES + databytes;
/* Inconvenient to bump nread here; do it in the switch */
nread = dataread(tp, infoptr, fixed_length);
switch (nread) {
case 0:
err("%s: no data on first trace", __FILE__);
default:
if (nread != databytes){
err("%s: first trace: " "read only %d bytes of %u",
__FILE__, nread, databytes);
}else{
nread += HDRBYTES;
}
}
if (infoptr->ftype == DISK) { /* compute ntr */
efseeko(fp, (off_t) 0LL,SEEK_END);
if( in_line_hdr ){
infoptr->ntr = (eftello(fp)-3600)/infoptr->nsegy;
efseeko(fp, (off_t) 3600+infoptr->nsegy,SEEK_SET);
}else{
infoptr->ntr = eftello(fp)/infoptr->nsegy;
efseeko(fp, (off_t) infoptr->nsegy ,SEEK_SET);
}
}
}else{
/* not first trace */
/*--------------------------------------------------------------------*\
A number of programs seek on the input file using either fseek(3c)
or rewind(3c) and then expect to read trace data. As a consequence
we need to check and offset the filepointer if needed.
\*--------------------------------------------------------------------*/
if( in_line_hdr && ftello( infoptr->infp ) == 0 ){
fseeko( infoptr->infp ,(off_t)3600L ,SEEK_SET );
}
nread = (int) efread(tp, 1, HDRBYTES, infoptr->infp);
switch( nread ){
case 0:
lastfp = infoptr->infp;
return 0; /* finished */
default:
if (nread != HDRBYTES){
err("%s: on trace #%ld read %d bytes expected %d bytes",
__FILE__,(infoptr->itr)+1,nread,HDRBYTES);
}
}
nread += dataread(tp, infoptr, fixed_length);
if (fixed_length && (tp->ns != infoptr->nsfirst)){
err("%s: on trace #%ld number of samples in header (%d) differs from number for first trace (%d)"
,__FILE__, (infoptr->itr)+1, tp->ns,
infoptr->nsfirst);
}
}
++(infoptr->itr);
lastfp = infoptr->infp;
return (nread);
}
static
int fgettr_internal(FILE *fp, segy *tp, cwp_Bool fixed_length)
{
int nread; /* bytes seen by fread calls */
off_t curoff;
if(fp != lastfp) /* search linked list for possible alternative */
searchlist(fp);
if (infoptr == ((struct insegyinfo *) NULL)) {
/* initialize new segy input stream */
unsigned int databytes; /* bytes from nsfirst */
/* allocate new segy input information table */
*oldinfoptr = (struct insegyinfo *)
malloc(sizeof(struct insegyinfo));
infoptr = *oldinfoptr;
infoptr->nextinfo = (struct insegyinfo *) NULL;
/* save FILE * ptr */
infoptr->infp = fp;
infoptr->itr = 0;
infoptr->ntr = -1;
/* allocate XDR struct and associate FILE * ptr */
infoptr->segy_xdr = (XDR *) malloc(sizeof(XDR));
switch (infoptr->ftype = filestat(fileno(fp))) {
case DIRECTORY:
err("%s: segy input can't be a directory", __FILE__);
case TTY:
err("%s: segy input can't be tty", __FILE__);
break;
default: /* the rest are ok */
break;
}
/* xdrstdio_create(infoptr->segy_xdr,fp,XDR_DECODE); */
infoptr->buf = ealloc1(sizeof(segy),sizeof(char));
xdrmem_create(infoptr->segy_xdr, infoptr->buf, sizeof(segy), XDR_DECODE);
infoptr->bufstart = xdr_getpos(infoptr->segy_xdr);
/* retrieve segy trace header */
nread = efread(infoptr->buf ,1 ,HDRBYTES ,infoptr->infp);
if(nread != HDRBYTES || FALSE == xdrhdrsub(infoptr->segy_xdr,tp))
err("%s: bad first header", __FILE__);
/* Have the header, now for the data */
infoptr->nsfirst = tp->ns;
if (infoptr->nsfirst > SU_NFLTS)
err("%s: unable to handle %d > %d samples per trace",
__FILE__, infoptr->nsfirst, SU_NFLTS);
switch(tp->trid) {
case CHARPACK:
infoptr->bytesper = sizeof(char); break;
case SHORTPACK:
infoptr->bytesper = 2*sizeof(char); break;
default:
infoptr->bytesper = BYTES_PER_XDR_UNIT; break;
}
databytes = infoptr->bytesper * tp->ns;
infoptr->nsegy = databytes + HDRBYTES;
nread = dataread(infoptr, tp, fixed_length);
switch (nread) {
case 0: err("%s: no data on first trace", __FILE__);
default: if (nread != databytes)
err("%s: first trace: tried to read %d bytes "
"read %d bytes",
__FILE__, databytes, nread);
else nread += HDRBYTES;
}
if(infoptr->ftype == DISK) { /* compute ntr */
curoff = eftello(fp);
efseeko(fp,(off_t) 0,SEEK_END);
infoptr->ntr = eftello(fp)/infoptr->nsegy;
efseeko(fp, curoff, SEEK_SET); /* restore location */
}
} else { /* Not first entry */
xdr_setpos(infoptr->segy_xdr, infoptr->bufstart);
nread = efread(infoptr->buf ,1 ,HDRBYTES ,infoptr->infp);
if ( nread != HDRBYTES || FALSE == xdrhdrsub(infoptr->segy_xdr,tp)) nread=0;
if(nread == HDRBYTES)
nread += dataread(infoptr, tp, fixed_length);
if (nread <= 0) {
lastfp = infoptr->infp;
return 0;
}
if (fixed_length && (tp->ns != infoptr->nsfirst))
err("%s: on trace #%ld, "
"number of samples in header (%d) "
"differs from number for first trace (%d)",
__FILE__, infoptr->itr, tp->ns, infoptr->nsfirst);
}
++(infoptr->itr);
lastfp = infoptr->infp;
return (nread);
}
int
main (int argc, char **argv)
{
int n1,n2,n1tic,n2tic,nfloats,bbox[4],
i1,i2,grid1,grid2,style,
i3,n3,notitle2=0,
n1c,n2c,n1s,n2s,i1beg,i1end,i2beg,i2end,i1c,i2c,
n1dsp=0,n2dsp=0,n3dsp=0,loopdsp,
nz,iz,i1step,i2step,verbose;
float labelsize,titlesize,perc,clip,bperc,wperc,bclip,wclip,
d1,f1,d2,f2,*z,*temp,zscale,zoffset,zi,
f3,d3,f3s,
xbox,ybox,wbox,hbox,
x1beg,x1end,x2beg,x2end,
x1min,x1max,x2min,x2max,
d1num,f1num,d2num,f2num,
p1beg,p1end,p2beg,p2end,matrix[6],
d1s,d2s;
unsigned char *cz,*czp,*sz;
char *label1="",*label2="",*title="",*title2="",
*labelfont="Helvetica",*titlefont="Helvetica-Bold",
*styles="seismic",*grid1s="none",*grid2s="none";
char title2s[80],c80[80];
FILE *infp=stdin;
/* initialize getpar */
initargs(argc,argv);
requestdoc(1);
/* get parameters describing 1st dimension sampling */
if (!getparint("n1",&n1)) err("must specify n1!\n");
if (!getparfloat("d1",&d1)) d1 = 1.0;
if (!getparfloat("f1",&f1)) f1 = 0.0;
/* get parameters describing 2nd dimension sampling */
if (!getparint("n2",&n2)) {
if (efseeko(infp,(off_t) 0,SEEK_END)!=0)
err("must specify n2 if in a pipe!\n");
nfloats = (int) (eftello(infp)/((off_t) sizeof(float)));
efseeko(infp,(off_t) 0,SEEK_SET);
n2 = nfloats/n1;
n3 = 1;
}
if (!getparfloat("d2",&d2)) d2 = 1.0;
if (!getparfloat("f2",&f2)) f2 = 0.0;
/* get parameters describing 3rd dimension sampling */
if (!getparint("n3",&n3)) {
if (efseeko(infp,(off_t) 0,SEEK_END)!=0)
err("must specify n3 if in a pipe!\n");
nfloats = (int) (eftello(infp)/((off_t) sizeof(float)));
efseeko(infp,(off_t) 0,SEEK_SET);
n3 = nfloats/n1/n2;
}
if (!getparfloat("d3",&d3)) d3 = 1.0;
if (!getparfloat("f3",&f3)) f3 = d3;
/* set up desired looping mode */
if (!getparint("loopdsp",&loopdsp)) loopdsp = 3;
if (loopdsp == 3) {
n1dsp = n1;
n2dsp=n2;
n3dsp=n3;
} else if (loopdsp == 1) {
n1dsp = n2;
n2dsp=n3;
n3dsp=n1;
} else if (loopdsp == 2) {
n1dsp = n1;
n2dsp=n3;
n3dsp=n2;
}
x1min = (d1>0.0)?f1:f1+(n1dsp-1)*d1;
x1max = (d1<0.0)?f1:f1+(n1dsp-1)*d1;
x2min = (d2>0.0)?f2:f2+(n2dsp-1)*d2;
x2max = (d2<0.0)?f2:f2+(n2dsp-1)*d2;
/* read binary data to be plotted */
nz = n1*n2*n3;
z = ealloc1float(nz);
if (fread(z,sizeof(float),nz,infp)!=nz)
err("error reading input file!\n");
/* if necessary, determine clips from percentiles */
if (getparfloat("clip",&clip)) {
bclip = clip;
wclip = -clip;
}
if ((!getparfloat("bclip",&bclip) || !getparfloat("wclip",&wclip)) &&
!getparfloat("clip",&clip)) {
perc = 100.0; getparfloat("perc",&perc);
temp = ealloc1float(nz);
for (iz=0; iz<nz; iz++)
temp[iz] = z[iz];
if (!getparfloat("bclip",&bclip)) {
bperc = perc; getparfloat("bperc",&bperc);
iz = (nz*bperc/100.0);
if (iz<0) iz = 0;
if (iz>nz-1) iz = nz-1;
qkfind(iz,nz,temp);
bclip = temp[iz];
}
if (!getparfloat("wclip",&wclip)) {
wperc = 100.0-perc; getparfloat("wperc",&wperc);
iz = (nz*wperc/100.0);
if (iz<0) iz = 0;
if (iz>nz-1) iz = nz-1;
qkfind(iz,nz,temp);
wclip = temp[iz];
}
free1float(temp);
}
/* transpose data if needed */
if (loopdsp == 1) {
temp = ealloc1float(nz);
for (iz=0;iz<nz;iz++) temp[iz] = z[iz];
for (i3=0;i3<n3;i3++) {
for (i2=0;i2<n2;i2++) {
for(i1=0;i1<n1;i1++) {
z[i2+i3*n2+i1*n2*n3]
= temp[i1+i2*n1+i3*n1*n2];
}
}
}
free1float(temp);
} else if (loopdsp == 2) {
temp = ealloc1float(nz);
for (iz=0;iz<nz;iz++) temp[iz] = z[iz];
for (i3=0;i3<n3;i3++) {
for (i2=0;i2<n2;i2++) {
for(i1=0;i1<n1;i1++) {
z[i1+i3*n1+i2*n1*n3]
= temp[i1+i2*n1+i3*n1*n2];
}
}
}
free1float(temp);
}
verbose = 1; getparint("verbose",&verbose);
if (verbose) warn("bclip=%g wclip=%g",bclip,wclip);
/* get scaled sampling intervals */
d1s = 1.0; getparfloat("d1s",&d1s);
d2s = 1.0; getparfloat("d2s",&d2s);
d1s = fabs(d1s); d1s *= d1;
d2s = fabs(d2s); d2s *= d2;
/* get axes parameters */
xbox = 1.0; getparfloat("xbox",&xbox);
ybox = 1.5; getparfloat("ybox",&ybox);
wbox = 6.0; getparfloat("wbox",&wbox);
hbox = 8.0; getparfloat("hbox",&hbox);
x1beg = x1min; getparfloat("x1beg",&x1beg);
x1end = x1max; getparfloat("x1end",&x1end);
d1num = 0.0; getparfloat("d1num",&d1num);
f1num = x1min; getparfloat("f1num",&f1num);
n1tic = 1; getparint("n1tic",&n1tic);
getparstring("grid1",&grid1s);
if (STREQ("dot",grid1s))
grid1 = DOT;
else if (STREQ("dash",grid1s))
grid1 = DASH;
else if (STREQ("solid",grid1s))
grid1 = SOLID;
else
grid1 = NONE;
getparstring("label1",&label1);
x2beg = x2min; getparfloat("x2beg",&x2beg);
x2end = x2max; getparfloat("x2end",&x2end);
d2num = 0.0; getparfloat("d2num",&d2num);
f2num = 0.0; getparfloat("f2num",&f2num);
n2tic = 1; getparint("n2tic",&n2tic);
getparstring("grid2",&grid2s);
if (STREQ("dot",grid2s))
grid2 = DOT;
else if (STREQ("dash",grid2s))
grid2 = DASH;
else if (STREQ("solid",grid2s))
grid2 = SOLID;
else
grid2 = NONE;
getparstring("label2",&label2);
getparstring("labelfont",&labelfont);
labelsize = 18.0; getparfloat("labelsize",&labelsize);
getparstring("title",&title);
if (!getparstring("title2",&title2)) notitle2=1;
getparstring("titlefont",&titlefont);
titlesize = 24.0; getparfloat("titlesize",&titlesize);
getparstring("style",&styles);
if (STREQ("normal",styles))
style = NORMAL;
else
style = SEISMIC;
/* adjust x1beg and x1end to fall on sampled values */
i1beg = NINT((x1beg-f1)/d1);
i1beg = MAX(0,MIN(n1dsp-1,i1beg));
x1beg = f1+i1beg*d1;
i1end = NINT((x1end-f1)/d1);
i1end = MAX(0,MIN(n1dsp-1,i1end));
x1end = f1+i1end*d1;
/* adjust x2beg and x2end to fall on sampled values */
i2beg = NINT((x2beg-f2)/d2);
i2beg = MAX(0,MIN(n2dsp-1,i2beg));
x2beg = f2+i2beg*d2;
i2end = NINT((x2end-f2)/d2);
i2end = MAX(0,MIN(n2dsp-1,i2end));
x2end = f2+i2end*d2;
/* allocate space for image bytes */
n1c = 1+abs(i1end-i1beg);
n2c = 1+abs(i2end-i2beg);
/* convert data to be imaged into unsigned characters */
zscale = (wclip!=bclip)?255.0/(wclip-bclip):1.0e10;
zoffset = -bclip*zscale;
i1step = (i1end>i1beg)?1:-1;
i2step = (i2end>i2beg)?1:-1;
/* determine sampling after scaling */
n1s = MAX(1,NINT(1+(n1c-1)*d1/d1s));
d1s = (n1s>1)?d1*(n1c-1)/(n1s-1):d1;
n2s = MAX(1,NINT(1+(n2c-1)*d2/d2s));
d2s = (n2s>1)?d2*(n2c-1)/(n2s-1):d2;
/* convert axes box parameters from inches to points */
xbox *= 72.0;
ybox *= 72.0;
wbox *= 72.0;
hbox *= 72.0;
/* set bounding box */
psAxesBBox3(
xbox,ybox,wbox,hbox,
labelfont,labelsize,
titlefont,titlesize,
style,bbox);
boundingbox(bbox[0],bbox[1],bbox[2],bbox[3]);
/* begin PostScript */
beginps();
/* loop over n3 */
for(i3=0;i3<n3dsp;i3++) {
cz = ealloc1(n1c*n2c,sizeof(char));
czp = cz;
for (i1c=0,i1=i1beg; i1c<n1c; i1c++,i1+=i1step) {
for (i2c=0,i2=i2beg; i2c<n2c; i2c++,i2+=i2step) {
zi = zoffset
+z[i1+i2*n1dsp+i3*n1dsp*n2dsp]*zscale;
if (zi<0.0) zi = 0.0;
if (zi>255.0) zi = 255.0;
*czp++ = (unsigned char)zi;
}
}
/* if necessary, interpolate to scaled sampling intervals */
if (n1s!=n1c || n2s!=n2c) {
sz = ealloc1(n1s*n2s,sizeof(char));
intl2b(n2c,d2,0.0,n1c,d1,0.0,cz,
n2s,d2s,0.0,n1s,d1s,0.0,sz);
free1(cz);
} else {
sz = cz;
}
/* determine axes pads */
p1beg = (x1end>x1beg)?-fabs(d1s)/2:fabs(d1s)/2;
p1end = (x1end>x1beg)?fabs(d1s)/2:-fabs(d1s)/2;
p2beg = (x2end>x2beg)?-fabs(d2s)/2:fabs(d2s)/2;
p2end = (x2end>x2beg)?fabs(d2s)/2:-fabs(d2s)/2;
newpage("1",i3+1);
/* save graphics state */
gsave();
/* translate coordinate system by box offset */
translate(xbox,ybox);
/* determine image matrix */
if (style==NORMAL) {
matrix[0] = 0; matrix[1] = n1s; matrix[2] = n2s;
matrix[3] = 0; matrix[4] = 0; matrix[5] = 0;
} else {
matrix[0] = n2s; matrix[1] = 0; matrix[2] = 0;
matrix[3] = -n1s; matrix[4] = 0; matrix[5] = n1s;
}
scale(wbox,hbox);
/* draw the image (before axes so grid lines are visible) */
image(n2s,n1s,8,matrix,sz);
/* restore graphics state */
grestore();
/* update title2 only if n3>1*/
strcpy(title2s,title2);
if ( notitle2 == 0 ) {
char *nullchar="";
f3s = f3 + i3 * d3;
sprintf(c80,"= %.4g %s",f3s,nullchar);
strcat(title2s,c80);
}
/* draw axes and title */
psAxesBox3(
xbox,ybox,wbox,hbox,
x1beg,x1end,p1beg,p1end,
d1num,f1num,n1tic,grid1,label1,
x2beg,x2end,p2beg,p2end,
d2num,f2num,n2tic,grid2,label2,
labelfont,labelsize,
title,titlefont,titlesize,
style, title2s);
showpage();
}
/* end PostScript */
endps();
return EXIT_SUCCESS;
}
int
main(int argc,char **argv)
{
int n1, n2, n3, depth, iter, slowness;
int nn1, nn2, nn3, nrvl,mode;
float ***v2, pdv;
float r1, r2, r3, ***vel, mu, vminc, vmaxc;
int i1beg, i1end, i2beg, i2end, i3beg, i3end;
int i1, i2, i3;
int j1, j2, j3, ih, ilay, j;
float vlsd, tmp, vorig;
int add, how;
unsigned int seed; /* random number seed */
float cvel;
FILE *invp=stdin, *outvp=stdout;
/* initialization */
initargs(argc,argv) ;
requestdoc(0);
/*-----------get required parameters-----------*/
if( !getparint("n1",&n1) ) n1 = 0 ;
if( n1 <= 0 ) err("sample number of 1st dimension invalid" ) ;
if( !getparint("n2",&n2) ) n2 = 0 ;
if( n2 <= 0 ) err("sample number of 2nd dimension invalid" ) ;
/*-----------get optional parameters-----------*/
if( !getparint("n3",&n3) ) n3 = 1 ;
/* get mode from user */
if( !getparint("mode",&mode) ) mode = 1 ;
if( mode < 1 || mode > 2 ) err("mode must be 1 or 2" ) ;
/* Set seed */
if (!getparuint("seed", &seed)) { /* if not supplied, use clock */
if (-1 == (seed = (unsigned int) time((time_t *) NULL))) {
err("time() failed to set seed");
}
}
sranuni(seed);
if (mode==2) warn("Random seed for layers = %i",seed);
/* single RVL geometry */
if( !getparint("i1beg",&i1beg) ) i1beg = 0 ;
if( !getparint("i1end",&i1end) ) i1end = n1/5 ;
if( !getparint("i2beg",&i2beg) ) i2beg = 0 ;
if( !getparint("i2end",&i2end) ) i2end = n2 ;
if( !getparint("i3beg",&i3beg) ) i3beg = 0 ;
if( !getparint("i3end",&i3end) ) i3end = n3 ;
/* constant velocity layer */
if( !getparfloat("cvel",&cvel ) ) cvel = 0. ;
/* smoothing parameters */
if( !getparfloat("r1",&r1) || n1<4) r1 = 0. ;
if( !getparfloat("r2",&r2) || n2<4) r2 = 0. ;
if( !getparfloat("r3",&r3) || n3<4) r3 = 0. ;
/* many layers */
if( !getparint("nrvl",&nrvl) ) nrvl = n1/10 ;
if( nrvl > n1-1 ) err("nrvl cannot be greater than n1" ) ;
if( !getparfloat("pdv",&pdv) ) pdv = 10. ;
/* scale smoothing parameters */
r1 = 0.5*r1*r1 ;
r2 = 0.5*r2*r2 ;
r3 = 0.5*r3*r3 ;
/* get iteration number for smoothing operator */
iter = 2;
/* description for vertical dimension */
depth = 1;
/* relative weight at bottom */
mu = 1.0;
/* smoothing on velocity or slowness */
if(!getparint("slowness",&slowness) ) slowness = 0;
/* clips of velocity before smoothing */
vminc = 0;
vmaxc = 99999;
/* allocate input file */
vel = alloc3float(n1,n2,n3) ;
/* read input velocity file */
efseeko(invp,(off_t) 0,SEEK_SET);
fread((char *)vel[0][0],sizeof(float),n1*n2*n3,invp);
/* get layer random velocity std deviation */
i1 = (i1beg + i1end)/2;
vorig = vel[0][0][i1];
if( !getparfloat("vlsd",&vlsd) ) vlsd = 0.3*vorig;
/* get add and how params */
if( !getparint("add",&add) ) add = 1 ;
if( add < 0 || add > 1 ) err("add must be 0 or 1" ) ;
if( !getparint("how",&how) ) how = 0 ;
if( how < 0 || how > 2 ) err("how must be 0,1, or 2" ) ;
/* single layer with point-to-point random velocities */
if (mode==1) {
/* dimensions of RVL */
nn1 = i1end - i1beg;
nn2 = i2end - i2beg;
nn3 = i3end - i3beg;
/* allocate RVL memory */
v2 = alloc3float(nn1,nn2,nn3) ;
/* make the single RVL ...
loop over axis 3 (y) */
for (i3=0; i3<nn3; ++i3) {
/* loop over axis 2 (x) */
for (i2=0; i2<nn2; ++i2) {
/* loop over axis 1 (z) */
for (i1=0; i1<nn1; ++i1) {
if (how==0) {
tmp = vlsd*(0.5-franuni());
} else if (how==1) {
tmp = - vlsd*franuni();
} else if (how==2) {
tmp = vlsd*franuni();
}
if (cvel>0.) {
vel[i3][i2][i1] = cvel;
} else {
vel[i3][i2][i1] += tmp;
}
}
}
}
/* perform smoothing operation */
vsm3d(v2,nn3,nn2,nn1,iter,depth,r3,r2,r1,mu,slowness,vminc,vmaxc);
/* add in, or replace with, the random velocity layer...
loop over axis 3 (y) */
for (i3=i3beg; i3<i3end; ++i3) {
j3 = i3 - i3beg;
/* loop over axis 2 (x) */
for (i2=i2beg; i2<i2end; ++i2) {
j2 = i2 - i2beg;
/* loop over axis 1 (z) */
for (i1=i1beg; i1<i1end; ++i1) {
j1 = i1 - i1beg;
if (add==1) {
if (how==1) {
vel[i3][i2][i1] -= v2[j3][j2][j1];
} else {
vel[i3][i2][i1] += v2[j3][j2][j1];
}
} else if (add==0) {
if (how==1) {
vel[i3][i2][i1] = vorig - v2[j3][j2][j1];
} else {
vel[i3][i2][i1] = vorig + v2[j3][j2][j1];
}
}
if (cvel>0.) {
vel[i3][i2][i1] = cvel;
}
}
}
}
}
/* many constant (random) velocity layers with random thickness */
if (mode==2) {
/* axis 1 (z) index */
i1 = 0;
/* loop over layers */
for (ilay=0; ilay<nrvl; ++ilay) {
/* set addative vel for this layer */
if (n3>2) {
i3 = n3/2;
} else {
i3 = 0;
}
i2 = n2/2;
tmp = (0.5-franuni())*pdv*vel[i3][i2][i1]/100;
/* set thickness of this layer (depth samples) */
ih = franuni()*n1/(nrvl-ilay) + 1;
/* loop over depth samples in layer */
for (j=0; j<ih; ++j) {
/* loop over axis 3 (y) */
for (i3=0; i3<n3; ++i3) {
/* loop over axis 2 (x) */
for (i2=0; i2<n2; ++i2) {
vel[i3][i2][i1] += tmp;
}
}
i1 += 1;
}
}
}
/* write output velocity file */
fwrite((char *)vel[0][0],sizeof(float),n1*n2*n3,outvp);
/* close input and output files */
fclose(invp) ;
fclose(outvp) ;
return(CWP_Exit());
}
int
main (int argc, char **argv)
{
int n1,n2,n3,nbpe,perm,i1,i2,i3,verbose;
char *v=NULL;
char *tempstem=NULL, **tempdirs=NULL;
int ntempdirs;
char tmpstem[] = "foo";
char tmpdir[] = "/tmp";
FILE *infp=stdin,*outfp=stdout;
VND *handle;
long N[3] ;
long key[3] ;
/* hook up getpar */
initargs(argc,argv);
requestdoc(1);
/* get parameters */
if (!getparint("n1",&n1)) err("must specify n1!");
if (!getparint("n2",&n2)) err("must specify n2!");
ntempdirs = countparval("scratchdir");
if(ntempdirs > 0) {
tempdirs = (char **) ealloc1(ntempdirs, sizeof(char *));
getparstringarray("scratchdir",tempdirs);
} else {
ntempdirs = 1;
tempdirs = (char **) ealloc1(ntempdirs, sizeof(char *));
strcpy(tempdirs[0],tmpdir);
}
if (!getparstring("scratchstem",&tempstem))
tempstem = &tmpstem[0];
if (!getparint("nbpe",&nbpe)) nbpe = sizeof(float);
if (!getparint("perm",&perm)) perm = 231; /* trace to time slice */
if (!getparint("n3",&n3)) {
if (efseeko(infp,(off_t) 0,SEEK_END)==-1)
err("input file size unknown; specify n3\n");
n3 = (int) (eftello(infp)/(((off_t)n1)*((off_t)n2)*((off_t)nbpe)));
efseeko(infp, (off_t) 0,SEEK_SET);
}
verbose = 0; getparint("verbose",&verbose);
if (verbose) warn("n1=%d n2=%d n3=%d nbpe=%d perm=%d\n",n1,n2,n3,nbpe,perm);
/* allocate space for a single vector in any dimension */
v = ealloc1((n1+n2+n3),nbpe);
/* allocate big matrix state */
N[0] = n1; N[1] = n2; N[2] = n3;
handle = VNDop(2,200000000,3,N,1,nbpe,tempstem,ntempdirs,tempdirs,1);
/* put vectors along 1st dimension to big matrix */
if (verbose) warn("Reading input file");
for (i3=0; i3<n3; i3++) {
for (i2=0; i2<n2; i2++) {
if (fread(v,1,nbpe*n1,infp)!=nbpe*n1)
err("Error reading input file: i2=%d\n",i2);
key[0] = 0; key[1] = i2; key[2] = i3;
VNDrw('w',0,handle,0,key,0,v,0,1,n1,21,NULL);
}
}
/* get vectors along 2nd dimension from big matrix */
if (verbose) warn("Writing output file");
switch(perm) {
case 123:
for (i3=0; i3<n3; i3++) {
for (i2=0; i2<n2; i2++) {
key[0] = 0; key[1] = i2; key[2] = i3;
VNDrw('r',0,handle,0,key,0,v,0,1,n1,123,NULL);
if (fwrite(v,1,nbpe*n1,outfp)!=nbpe*n1)
err("Error writing output file: i2=%d i3=%d",i2,i3);
}
}
break;
case 132:
for (i2=0; i2<n2; i2++) {
for (i3=0; i3<n3; i3++) {
key[0] = 0; key[1] = i2; key[2] = i3;
VNDrw('r',0,handle,0,key,0,v,0,1,n1,132,NULL);
if (fwrite(v,1,nbpe*n1,outfp)!=nbpe*n1)
err("Error writing output file: i2=%d i3=%d",i2,i3);
}
}
break;
case 213:
for (i3=0; i3<n3; i3++) {
for (i1=0; i1<n1; i1++) {
key[0] = i1; key[1] = 0; key[2] = i3;
VNDrw('r',0,handle,1,key,0,v,0,1,n2,213,NULL);
if (fwrite(v,1,nbpe*n2,outfp)!=nbpe*n2)
err("Error writing output file: i1=%d i3=%d",i1,i3);
}
}
break;
case 231:
for (i1=0; i1<n1; i1++) {
for (i3=0; i3<n3; i3++) {
key[0] = i1; key[1] = 0; key[2] = i3;
VNDrw('r',0,handle,1,key,0,v,0,1,n2,231,NULL);
if (fwrite(v,1,nbpe*n2,outfp)!=nbpe*n2)
err("Error writing output file: i1=%d i3=%d",i1,i3);
}
}
break;
case 312:
for (i2=0; i2<n2; i2++) {
for (i1=0; i1<n1; i1++) {
key[0] = i1; key[1] = i2; key[2] = 0;
VNDrw('r',0,handle,2,key,0,v,0,1,n3,312,NULL);
if (fwrite(v,1,nbpe*n3,outfp)!=nbpe*n3)
err("Error writing output file: i1=%d i2=%d",i1,i2);
}
}
break;
case 321:
for (i1=0; i1<n1; i1++) {
for (i2=0; i2<n2; i2++) {
key[0] = i1; key[1] = i2; key[2] = 0;
VNDrw('r',0,handle,2,key,0,v,0,1,n3,321,NULL);
if (fwrite(v,1,nbpe*n3,outfp)!=nbpe*n3)
err("Error writing output file: i1=%d i2=%d",i1,i2);
}
}
break;
default:
err("Unrecognized transpose permutation %d",perm);
}
/* free big matrix state */
VNDcl(handle,1);
if (verbose) warn("Transpose done!");
return(CWP_Exit());
}
int
main (int argc, char **argv)
{
int nt; /* number of time samples */
int nz; /* number of migrated depth samples */
int nx; /* number of horizontal samples */
int nxshot; /* number of shots to be migrated */
int iz,iw,ix,it,ik; /* loop counters */
int igx; /* integerized gx value */
int ntfft,nxfft; /* fft size */
int nw,truenw,nk; /* number of wave numbers */
int dip=65; /* dip angle */
int oldigx=0; /* old value of integerized gx value */
int oldisx=0; /* old value of integerized sx value */
float sx,gx; /* x source and geophone location */
float gxmin=0.0,gxmax=0.0; /* x source and geophone location */
float min_sx_gx; /* min(sx,gx) */
float oldgx; /* old gx position */
float oldgxmin; /* old gx position */
float oldgxmax; /* old gx position */
float oldsx=0.0; /* old sx position */
int isx=0,nxo; /* index for source and geophone */
int ix1,ix2,ix3,ixshot,il=0,ir=0; /* dummy index */
int lpad,rpad; /* padding on both sides of the migrated section */
float *wl=NULL,*wtmp=NULL;
float fmax;
float f1,f2,f3,f4;
int nf1,nf2,nf3,nf4;
int ntw;
float dt=0.004,dz; /* time and depth sampling interval */
float dw,dk; /* wavenumber and frequency sampling interval */
float fw,fk; /* first wavenumber and frequency */
float w,k; /* wavenumber and frequency */
float dx; /* spatial sampling interval */
float **p=NULL;
float **cresult=NULL; /* input, output data */
float v1,vmin;
double kz1,kz2;
double phase1;
float **v=NULL;
float **vp=NULL;
complex cshift1,cshift2;
complex *wlsp=NULL;
complex **cp=NULL;
complex **cp1=NULL;
complex **cq=NULL;
complex **cq1=NULL; /*complex input,output*/
char *vfile=""; /* name of file containing velocities */
FILE *vfp=NULL;
int verbose; /* verbose flag */
/* hook up getpar to handle the parameters */
initargs(argc,argv);
requestdoc(1);
/* get optional parameters */
MUSTGETPARINT("nz",&nz);
MUSTGETPARFLOAT("dz",&dz);
MUSTGETPARSTRING("vfile", &vfile);
MUSTGETPARINT("nxo",&nxo);
MUSTGETPARINT("nxshot",&nxshot);
if (!getparfloat("fmax",&fmax)) fmax = 25. ;
if (!getparfloat("f1",&f1)) f1 = 10.0;
if (!getparfloat("f2",&f2)) f2 = 20.0;
if (!getparfloat("f3",&f3)) f3 = 40.0;
if (!getparfloat("f4",&f4)) f4 = 50.0;
if (!getparint("lpad",&lpad)) lpad=9999;
if (!getparint("rpad",&rpad)) rpad=9999;
if (!getparint("dip",&dip)) dip=65;
if (!getparint("verbose",&verbose)) verbose = 0;
/* allocate space */
cresult = alloc2float(nz,nxo);
vp=alloc2float(nxo,nz);
/* load velocity file */
vfp=efopen(vfile,"r");
efread(vp[0],FSIZE,nz*nxo,vfp);
efclose(vfp);
/* zero out cresult array */
memset((void *) cresult[0], 0, nxo*nz*FSIZE);
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
get_sx_gx(&sx,&gx);
min_sx_gx = MIN(sx,gx);
gxmin=gxmax=gx;
erewind(stdin);
/*
sx = sx - min_sx_gx;
gx = gx - min_sx_gx;
*/
/* let user give dt and/or dx from command line */
if (!getparfloat("dt", &dt)) {
if (tr.dt) { /* is dt field set? */
dt = ((double) tr.dt)/1000000.0;
} else { /* dt not set, assume 4 ms */
dt = 0.004;
warn("tr.dt not set, assuming dt=0.004");
}
}
if (!getparfloat("dx",&dx)) {
if (tr.d2) { /* is d2 field set? */
dx = tr.d2;
} else {
dx = 1.0;
warn("tr.d2 not set, assuming d2=1.0");
}
}
do { /* begin loop over shots */
/* determine frequency sampling interval*/
ntfft = npfar(nt);
nw = ntfft/2+1;
dw = 2.0*PI/(ntfft*dt);
/* compute the index of the frequency to be migrated */
fw=2.0*PI*f1;
nf1=fw/dw+0.5;
fw=2.0*PI*f2;
nf2=fw/dw+0.5;
fw=2.0*PI*f3;
nf3=fw/dw+0.5;
fw=2.0*PI*f4;
nf4=fw/dw+0.5;
/* the number of frequencies to migrated */
truenw=nf4-nf1+1;
fw=0.0+nf1*dw;
if (verbose)
warn("nf1=%d nf2=%d nf3=%d nf4=%d nw=%d",nf1,nf2,nf3,nf4,truenw);
/* allocate space */
wl=alloc1float(ntfft);
wlsp=alloc1complex(nw);
/* generate the Ricker wavelet */
wtmp=ricker(fmax,dt,&ntw);
/* zero out wl[] array */
memset((void *) wl, 0, ntfft*FSIZE);
/* CHANGE BY CHRIS STOLK, Dec. 11, 2005 */
/* The next two lines are the old code, */
/* it is erroneous because the peak of */
/* the wavelet occurs at positive time */
/* instead of time zero. */
for(it=0;it<ntw;it++)
wl[it]=wtmp[it];
/* New code: we put in the wavelet in a centered fashion */
/*
for(it=0;it<ntw;it++) {
wl[(it-ntw/2+ntfft) % ntfft]=wtmp[it];
}
*/
/* warn("%12i %12f \n",(it-ntw/2+ntfft) % ntfft,wtmp[it]); */
/* End of new code */
free1float(wtmp);
/* fourier transform wl array */
pfarc(-1,ntfft,wl,wlsp);
/* CS TEST: this was used to output the array wlsp
(the wavelet in the frequency domain) to the file CSinfo,
no longer needed and commented out */
/*
FILE *CSinfo;
CSinfo=fopen("CSinfo","w");
fprintf(CSinfo,"ntfft=%10i\n",ntfft);
fprintf(CSinfo,"ntw=%10i\n",ntw);
for(iw=0;iw<ntfft/2+1;iw++)
fprintf(CSinfo,"%12f %12f \n",wlsp[iw].r,wlsp[iw].i);
fclose(CSinfo);
*/
/* conclusion from the analysis of this info:
the wavelet (whose fourier transform is in wlsp)
is not zero phase!!!
so there is a timeshift error!!!
Conclusion obtained dec 11 2005 */
/* CS */
/* allocate space */
p = alloc2float(ntfft,nxo);
cq = alloc2complex(nw,nxo);
/* zero out p[][] array */
memset((void *) p[0], 0, ntfft*nxo*FSIZE);
/* initialize a number of items before looping over traces */
nx = 0;
if (gx < 0 ) {
igx=gx/dx + nxo;
} else {
igx=gx/dx ;
}
oldigx=igx;
oldsx=sx;
oldgx=gx;
oldgxmax=gxmax;
oldgxmin=gxmin;
while(gettr(&tr)) { /* begin looping over traces within a shot gather */
/* get sx and gx */
get_sx_gx(&sx,&gx);
/*
warn("%d nx=%d", igx, nx);
sx = (sx - min_sx_gx);
gx = (gx - min_sx_gx);
*/
if (gx < 0 ) {
igx=gx/dx + nxo;
} else {
igx=gx/dx ;
}
if (igx==oldigx)
warn("repeated igx!!! check dx or scalco value!!!");
oldigx = igx;
if(tr.sx!=oldsx){ efseeko(stdin,(off_t)(-240-nt*4),SEEK_CUR); break;}
if(gxmin>gx)gxmin=gx;
if(gxmax<gx)gxmax=gx;
if(verbose)
warn(" inside loop: min_sx_gx %f isx %d igx %d gx %f sx %f",min_sx_gx,isx,igx,gx,sx);
/* sx, gx must increase monotonically */
if (!(oldsx <= sx) )
err("sx field must be monotonically increasing!");
if (!(oldgx <= gx) )
err("gx field must be monotonically increasing!");
memcpy( (void *) p[igx], (const void *) tr.data,nt*FSIZE);
++nx;
}
isx=oldsx/dx;
if (isx==oldisx)
warn("repeated isx!!! check dx or scalco value!!!");
oldisx=isx;
ixshot=isx;
if(verbose) {
warn("sx %f, gx %f , gxmin %f gxmax %f nx %d",sx,gx,gxmin,gxmax, nx);
warn("isx %d igx %d ixshot %d" ,isx,igx,ixshot);
}
/* transform the shot gather from time to frequency domain */
pfa2rc(1,1,ntfft,nxo,p[0],cq[0]);
/* compute the most left and right index for the migrated */
/* section */
ix1=oldsx/dx;
ix2=gxmin/dx;
ix3=gxmax/dx;
if(ix1>=ix3)ix3=ix1;
if(ix1<=ix2)ix2=ix1;
il=ix2;
ir=ix3;
ix2-=lpad;
ix3+=rpad;
if(ix2<0)ix2=0;
if(ix3>nxo-1)ix3=nxo-1;
/* the total traces to be migrated */
nx=ix3-ix2+1;
nw=truenw;
/* determine wavenumber sampling (for complex to complex FFT) */
nxfft = npfa(nx);
nk = nxfft;
dk = 2.0*PI/(nxfft*dx);
fk = -PI/dx;
/* allocate space for velocity profile within the aperature */
v=alloc2float(nx,nz);
for(iz=0;iz<nz;iz++)
for(ix=0;ix<nx;ix++)
v[iz][ix]=vp[iz][ix+ix2];
/* allocate space */
cp = alloc2complex(nx,nw);
cp1 = alloc2complex(nx,nw);
/* transpose the frequency domain data from */
/* data[ix][iw] to data[iw][ix] and apply a */
/* Hamming at the same time */
for (ix=0; ix<nx; ix++) {
for (iw=0; iw<nw; iw++){
float tmpp=0.0,tmppp=0.0;
if(iw>=(nf1-nf1)&&iw<=(nf2-nf1)){
tmpp=PI/(nf2-nf1);
tmppp=tmpp*(iw-nf1)-PI;
tmpp=0.54+0.46*cos(tmppp);
cp[iw][ix]=crmul(cq[ix+ix2][iw+nf1],tmpp);
} else {
if(iw>=(nf3-nf1)&&iw<=(nf4-nf1)){
tmpp=PI/(nf4-nf3);
tmppp=tmpp*(iw-nf3);
tmpp=0.54+0.46*cos(tmppp);
cp[iw][ix]=crmul(cq[ix+ix2][iw+nf1],tmpp);
} else {
cp[iw][ix]=cq[ix+ix2][iw+nf1];}
}
cp1[iw][ix]=cmplx(0.0,0.0);
}
}
for(iw=0;iw<nw;iw++){
cp1[iw][ixshot-ix2]=wlsp[iw+nf1];
}
if(verbose) {
warn("ixshot %d ix %d ix1 %d ix2 %d ix3 %d",ixshot,ix,ix1,ix2,ix3);
warn("oldsx %f ",oldsx);
}
free2float(p);
free2complex(cq);
free1float(wl);
free1complex(wlsp);
/* allocating space */
cq=alloc2complex(nxfft,nw);
cq1=alloc2complex(nxfft,nw);
/* loops over depth */
for(iz=0;iz<nz;++iz){
/* the imaging condition */
for(ix=0;ix<nx;ix++){
for(iw=0,w=fw;iw<nw;w+=dw,iw++){
complex tmp;
float ratio=10.0;
if(fabs(ix+ix2-ixshot)*dx<ratio*iz*dz)
tmp=cmul(cp[iw][ix],cp1[iw][ix]);
else
tmp=cmplx(0.0,0.0);
cresult[ix+ix2][iz]+=tmp.r/ntfft;
}
}
/* get the minimum velocity */
vmin=0;
for(ix=il-ix2;ix<=ir-ix2;ix++){
vmin+=1.0/v[iz][ix]/(ir-il+1);
}
vmin=1.0/vmin;
/* compute the shifted wavefield */
for (ik=0;ik<nx;++ik) {
for (iw=0; iw<nw; ++iw) {
cq[iw][ik] = ik%2 ? cneg(cp[iw][ik]) : cp[iw][ik];
cq1[iw][ik] = ik%2 ? cneg(cp1[iw][ik]) : cp1[iw][ik];
}
}
/* zero out cq[][] cq1[][] */
for (ik=nx; ik<nk; ++ik) {
for (iw=0; iw<nw; ++iw) {
cq[iw][ik] = cmplx(0.0,0.0);
cq1[iw][ik] = cmplx(0.0,0.0);
}
}
/* FFT to W-K domain */
pfa2cc(-1,1,nk,nw,cq[0]);
pfa2cc(-1,1,nk,nw,cq1[0]);
v1=vmin;
for(ik=0,k=fk;ik<nk;++ik,k+=dk) {
for(iw=0,w=fw;iw<nw;++iw,w+=dw){
if(w==0.0)w=1.0e-10/dt;
kz1=1.0-pow(v1*k/w,2.0);
if(kz1>0.15){
phase1 = -w*sqrt(kz1)*dz/v1;
cshift1 = cmplx(cos(phase1), sin(phase1));
cq[iw][ik] = cmul(cq[iw][ik],cshift1);
cq1[iw][ik] = cmul(cq1[iw][ik],cshift1);
} else {
cq[iw][ik] = cq1[iw][ik] = cmplx(0.0,0.0);
}
}
}
pfa2cc(1,1,nk,nw,cq[0]);
pfa2cc(1,1,nk,nw,cq1[0]);
for(ix=0;ix<nx;++ix) {
for(iw=0,w=fw;iw<nw;w+=dw,++iw){
float a=0.015,g=1.0;
int I=10;
if(ix<=I)g=exp(-a*(I-ix)*(I-ix));
if(ix>=nx-I)g=exp(-a*(-nx+I+ix)*(-nx+I+ix));
cq[iw][ix] = crmul( cq[iw][ix],1.0/nxfft);
cq[iw][ix] =ix%2 ? cneg(cq[iw][ix]) : cq[iw][ix];
kz2=(1.0/v1-1.0/v[iz][ix])*w*dz;
cshift2=cmplx(cos(kz2),sin(kz2));
cp[iw][ix]=cmul(cq[iw][ix],cshift2);
cq1[iw][ix] = crmul( cq1[iw][ix],1.0/nxfft);
cq1[iw][ix] =ix%2 ? cneg(cq1[iw][ix]) : cq1[iw][ix];
cp1[iw][ix]=cmul(cq1[iw][ix],cshift2);
}
}
}
free2complex(cp);
free2complex(cp1);
free2complex(cq);
free2complex(cq1);
free2float(v);
--nxshot;
} while(nxshot);
/* restore header fields and write output */
for(ix=0; ix<nxo; ix++){
tr.ns = nz;
tr.d1 = dz;
tr.d2 = dx;
tr.offset = 0;
tr.cdp = tr.tracl = ix;
memcpy( (void *) tr.data, (const void *) cresult[ix],nz*FSIZE);
puttr(&tr);
}
return(CWP_Exit());
}
int
main (int argc, char **argv)
{
int nt,nzt,nxt,nz,nxo,nxs,ns,nx,nr,is,ixo,ixs;
int ls,jtr,mtr,tracl,mzmax;
off_t nseek;
float ft,fzt,fxt,fz,fx,fxo,fs,fxs,dt,dzt,dxt,dz,dx,dxo,ds,dxs,
ext,ezt,es,ex,ez,xo,s,xs,xg,fpeak;
float v0,dvz;
float fmax,angmax,offmax,rmax,aperx;
float **mig,**migi,***ttab,**tb,**pb,**cosb,**sigb,**tsum,**tt;
char *infile="stdin",*outfile="stdout",*ttfile,*jpfile;
FILE *infp,*outfp,*ttfp,*jpfp;
Wavelet *w;
/* hook up getpar to handle the parameters */
initargs(argc, argv);
requestdoc(1);
/* open input and output files */
if( !getparstring("infile",&infile)) {
infp = stdin;
} else
if ((infp=fopen(infile,"r"))==NULL)
err("cannot open infile=%s\n",infile);
if( !getparstring("outfile",&outfile)) {
outfp = stdout;
} else {
outfp = fopen(outfile,"w");
}
efseeko(infp,(off_t) 0,SEEK_CUR);
warn("Got A");
efseeko(outfp,(off_t) 0,SEEK_CUR);
if( !getparstring("ttfile",&ttfile))
err("must specify ttfile!\n");
if ((ttfp=fopen(ttfile,"r"))==NULL)
err("cannot open ttfile=%s\n",ttfile);
if( !getparstring("jpfile",&jpfile)) {
jpfp = stderr;
} else
jpfp = fopen(jpfile,"w");
/* get information for seismogram traces */
if (!getparint("nt",&nt)) nt = 501;
if (!getparfloat("dt",&dt)) dt = 0.004;
if (!getparfloat("ft",&ft)) ft = 0.0;
if (!getparfloat("fmax",&fmax)) fmax = 1.0/(4*dt);
fpeak = 0.2/dt;
if (!getparint("nxs",&nxs)) nxs = 101;
if (!getparfloat("dxs",&dxs)) dxs = 15;
if (!getparfloat("fxs",&fxs)) fxs = 0.0;
if (!getparint("nxo",&nxo)) nxo = 1;
if (!getparfloat("dxo",&dxo)) dxo = 50;
if (!getparfloat("fxo",&fxo)) fxo = 0.0;
/* get traveltime table parameters */
if (!getparint("nxt",&nxt)) err("must specify nxt!\n");
if (!getparfloat("fxt",&fxt)) err("must specify fxt!\n");
if (!getparfloat("dxt",&dxt)) err("must specify dxt!\n");
if (!getparint("nzt",&nzt)) err("must specify nzt!\n");
if (!getparfloat("fzt",&fzt)) err("must specify fzt!\n");
if (!getparfloat("dzt",&dzt)) err("must specify dzt!\n");
if (!getparint("ns",&ns)) err("must specify ns!\n");
if (!getparfloat("fs",&fs)) err("must specify fs!\n");
if (!getparfloat("ds",&ds)) err("must specify ds!\n");
ext = fxt+(nxt-1)*dxt;
ezt = fzt+(nzt-1)*dzt;
es = fs+(ns-1)*ds;
/* check source and receiver coordinates */
for (ixs=0; ixs<nxs; ++ixs) {
xs = fxs+ixs*dxs;
for (ixo=0; ixo<nxo; ++ixo) {
xg = xs+fxo+ixo*dxo;
if (fs>xs || es<xs || fs>xg || es<xg)
err("shot or receiver lie outside of specified (x,z) grid\n");
}
}
/* get migration section parameters */
if (!getparint("nx",&nx)) err("must specify nx!\n");
if (!getparfloat("fx",&fx)) err("must specify fx!\n");
if (!getparfloat("dx",&dx)) err("must specify dx!\n");
if (!getparint("nz",&nz)) err("must specify nz!\n");
if (!getparfloat("fz",&fz)) err("must specify fz!\n");
if (!getparfloat("dz",&dz)) err("must specify dz!\n");
ex = fx+(nx-1)*dx;
ez = fz+(nz-1)*dz;
if(fxt>fx || ext<ex || fzt>fz || ezt<ez)
err(" migration section is out of traveltime table!\n");
if (!getparfloat("v0",&v0)) v0 = 1500;
if (!getparfloat("dvz",&dvz)) dvz = 0;
if (!getparfloat("angmax",&angmax)) angmax = 60.;
if (angmax<0.00001) err("angmax must be positive!\n");
mzmax = dx*sin(angmax*PI/180.)/dz;
if(mzmax<1) mzmax = 1;
if (!getparfloat("aperx",&aperx)) aperx = 0.5*nxt*dxt;
if (!getparint("ls",&ls)) ls = 1;
if (!getparint("mtr",&mtr)) mtr = 100;
fprintf(jpfp,"\n");
fprintf(jpfp," Modeling parameters\n");
fprintf(jpfp," ================\n");
fprintf(jpfp," infile=%s \n",infile);
fprintf(jpfp," outfile=%s \n",outfile);
fprintf(jpfp," ttfile=%s \n",ttfile);
fprintf(jpfp," \n");
fprintf(jpfp," nzt=%d fzt=%g dzt=%g\n",nzt,fzt,dzt);
fprintf(jpfp," nxt=%d fxt=%g dxt=%g\n",nxt,fxt,dxt);
fprintf(jpfp," ns=%d fs=%g ds=%g\n",ns,fs,ds);
fprintf(jpfp," \n");
fprintf(jpfp," nz=%d fz=%g dz=%g\n",nz,fz,dz);
fprintf(jpfp," nx=%d fx=%g dx=%g\n",nx,fx,dx);
fprintf(jpfp," \n");
fprintf(jpfp," nxs=%d fxs=%g dxs=%g\n",nxs,fxs,dxs);
fprintf(jpfp," nxo=%d fxo=%g dxo=%g\n",nxo,fxo,dxo);
fprintf(jpfp," \n");
/* compute reference traveltime and slowness */
offmax = MAX(ABS(fxo),ABS(fxo+(nxo-1)*dxo));
rmax = MAX(es-fxt,ext-fs);
rmax = MIN(rmax,0.5*offmax+aperx);
nr = 2+(int)(rmax/dx);
tb = ealloc2float(nzt,nr);
pb = ealloc2float(nzt,nr);
sigb = ealloc2float(nzt,nr);
cosb = ealloc2float(nzt,nr);
timeb(nr,nzt,dx,dzt,fzt,dvz,v0,tb,pb,sigb,cosb);
fprintf(jpfp," nt=%d ft=%g dt=%g fpeak=%g \n",nt,ft,dt,fpeak);
fprintf(jpfp," v0=%g dvz=%g \n",v0,dvz);
fprintf(jpfp," aperx=%g angmax=%g offmax=%g\n",aperx,angmax,offmax);
fprintf(jpfp," mtr=%d ls=%d\n",mtr,ls);
fprintf(jpfp," ================\n");
fflush(jpfp);
/* allocate space */
mig = ealloc2float(nz,nx);
migi = ealloc2float(nz+2*mzmax,nx);
ttab = ealloc3float(nzt,nxt,ns);
tt = ealloc2float(nzt,nxt);
tsum = ealloc2float(nzt,nxt);
/* make wavelet */
makericker(fpeak,dt,&w);
/* set constant segy trace header parameters */
memset((void *) &tr, 0, sizeof(segy));
tr.trid = 1;
tr.counit = 1;
tr.ns = nt;
tr.dt = 1.0e6*dt;
tr.delrt = 1.0e3*ft;
fprintf(jpfp," read traveltime tables \n");
fflush(jpfp);
/* compute traveltime residual */
for(is=0; is<ns; ++is){
nseek = (off_t) nxt*nzt*is;
efseeko(ttfp,nseek*((off_t) sizeof(float)),SEEK_SET);
fread(ttab[is][0],sizeof(float),nxt*nzt,ttfp);
s = fs+is*ds;
resit(nxt,fxt,dxt,nzt,nr,dx,tb,ttab[is],s);
}
fprintf(jpfp," read migration section \n");
fflush(jpfp);
/* read migration section */
fread(mig[0],sizeof(float),nx*nz,infp);
/* integrate migration section for constructing anti-aliasing
filter */
integ(mig,nz,dz,nx,mzmax,migi);
fprintf(jpfp," start synthesis ... \n");
fprintf(jpfp," \n");
fflush(jpfp);
jtr = 0;
/* loop over shots */
for (ixs=0,xs=fxs,tracl=0; ixs<nxs; ++ixs,xs+=dxs) {
/* loop over offsets */
for (ixo=0,xo=fxo; ixo<nxo; ++ixo,xo+=dxo) {
float as,res;
int is;
xg = xs+xo;
/* set segy trace header parameters */
tr.tracl = tr.tracr = ++tracl;
tr.fldr = 1+ixs;
tr.tracf = 1+ixo;
tr.offset = NINT(xo);
tr.sx = NINT(xs);
tr.gx = NINT(xg);
as = (xs-fs)/ds;
is = (int)as;
if(is==ns-1) is=ns-2;
res = as-is;
if(res<=0.01) res = 0.0;
if(res>=0.99) res = 1.0;
sum2(nxt,nzt,1-res,res,ttab[is],ttab[is+1],tsum);
as = (xg-fs)/ds;
is = (int)as;
if(is==ns-1) is=ns-2;
res = as-is;
if(res<=0.01) res = 0.0;
if(res>=0.99) res = 1.0;
sum2(nxt,nzt,1-res,res,ttab[is],ttab[is+1],tt);
sum2(nxt,nzt,1,1,tt,tsum,tsum);
fflush(jpfp);
/* make one trace */
maketrace(tr.data,nt,ft,dt,xs,xg,mig,migi,aperx,
nx,fx,dx,nz,fz,dz,mzmax,ls,angmax,v0,fmax,w,
tb,pb,sigb,cosb,nr,tsum,nxt,fxt,dxt,nzt,fzt,dzt);
/* write trace */
fputtr(outfp,&tr);
jtr++;
if((jtr-1)%mtr ==0 ){
fprintf(jpfp," generated trace %d\n",jtr);
fflush(jpfp);
}
}
}
fprintf(jpfp," generated %d traces in total\n",jtr);
fprintf(jpfp," \n");
fprintf(jpfp," output done\n");
fflush(jpfp);
efclose(jpfp);
efclose(outfp);
free2float(tsum);
free2float(tt);
free2float(pb);
free2float(tb);
free2float(cosb);
free2float(sigb);
free3float(ttab);
free2float(mig);
free2float(migi);
return(CWP_Exit());
}
int
main(int argc, char **argv)
{
int nt; /* number of time samples per trace */
float dt; /* time sampling interval */
float ft; /* time of first sample */
int it; /* time sample index */
int cdpmin; /* minimum cdp to process */
int cdpmax; /* maximum cdp to process */
float dx; /* cdp sampling interval */
int nx; /* number of cdps to process */
int nxfft; /* number of cdps after zero padding for fft */
int nxpad; /* minimum number of cdps for zero padding */
int ix; /* cdp index, starting with ix=0 */
int noffmix; /* number of offsets to mix */
float *tdmo; /* times at which rms velocities are specified */
float *vdmo; /* rms velocities at times specified in tdmo */
float gamma; /* upgoing to downging velocity ratio */
float *zoh=NULL;/* tabulated z/h */
float *boh=NULL;/* tabulated b/h */
int ntable; /* number of tabulated zoh and boh */
float sdmo; /* DMO stretch factor */
float s1; /* DMO stretch factor */
float s2; /* DMO stretch factor */
float temps; /* temp value used in excahnging s1 and s2 */
int flip; /* apply negative shifts and exchange s1 and s2 */
float sign; /* + if flip=0, negative if flip=1 */
int ntdmo; /* number tnmo values specified */
int itdmo; /* index into tnmo array */
int nvdmo; /* number vnmo values specified */
float fmax; /* maximum frequency */
float *vrms; /* uniformly sampled vrms(t) */
float **p; /* traces for one offset - common-offset gather */
float **q; /* DMO-corrected and mixed traces to be output */
float offset; /* source-receiver offset of current trace */
float oldoffset;/* offset of previous trace */
int noff; /* number of offsets processed in current mix */
int ntrace; /* number of traces processed in current mix */
int itrace; /* trace index */
int gottrace; /* non-zero if an input trace was read */
int done; /* non-zero if done */
int verbose; /* =1 for diagnostic print */
FILE *hfp; /* file pointer for temporary header file */
/* hook up getpar */
initargs(argc, argv);
requestdoc(1);
/* get information from the first header */
if (!gettr(&tr)) err("can't get first trace");
nt = tr.ns;
dt = tr.dt/1000000.0;
ft = tr.delrt/1000.0;
offset = tr.offset;
/* get parameters */
if (!getparint("cdpmin",&cdpmin)) err("must specify cdpmin");
if (!getparint("cdpmax",&cdpmax)) err("must specify cdpmax");
if (cdpmin>cdpmax) err("cdpmin must not be greater than cdpmax");
if (!getparfloat("dxcdp",&dx)) err("must specify dxcdp");
if (!getparint("noffmix",&noffmix)) err("must specify noffmix");
ntdmo = countparval("tdmo");
if (ntdmo==0) ntdmo = 1;
tdmo = ealloc1float(ntdmo);
if (!getparfloat("tdmo",tdmo)) tdmo[0] = 0.0;
nvdmo = countparval("vdmo");
if (nvdmo==0) nvdmo = 1;
if (nvdmo!=ntdmo) err("number of tdmo and vdmo must be equal");
vdmo = ealloc1float(nvdmo);
if (!getparfloat("vdmo",vdmo)) vdmo[0] = 1500.0;
for (itdmo=1; itdmo<ntdmo; ++itdmo)
if (tdmo[itdmo]<=tdmo[itdmo-1])
err("tdmo must increase monotonically");
if (!getparfloat("gamma",&gamma)) gamma = 0.5;
if (!getparint("ntable",&ntable)) ntable = 1000;
if (!getparfloat("sdmo",&sdmo)) sdmo = 1.0;
if (!getparint("flip",&flip)) flip=0;
if (flip)
sign = -1.0;
else
sign = 1.0;
if (!getparfloat("fmax",&fmax)) fmax = 0.5/dt;
if (!getparint("verbose",&verbose)) verbose=0;
checkpars();
/* allocate and generate tables of b/h and z/h if gamma not equal 1 */
if(gamma != 1.0){
zoh=alloc1float(ntable);
boh=alloc1float(ntable);
table(ntable, gamma, zoh, boh);
}
/* make uniformly sampled rms velocity function of time */
vrms = ealloc1float(nt);
mkvrms(ntdmo,tdmo,vdmo,nt,dt,ft,vrms);
/* determine number of cdps to process */
nx = cdpmax-cdpmin+1;
/* allocate and zero common-offset gather p(t,x) */
nxpad = 0.5*ABS(offset/dx);
nxfft = npfar(nx+nxpad);
p = ealloc2float(nt,nxfft+2);
for (ix=0; ix<nxfft; ++ix)
for (it=0; it<nt; ++it)
p[ix][it] = 0.0;
/* allocate and zero offset mix accumulator q(t,x) */
q = ealloc2float(nt,nx);
for (ix=0; ix<nx; ++ix)
for (it=0; it<nt; ++it)
q[ix][it] = 0.0;
/* open temporary file for headers */
hfp = tmpfile();
/* initialize */
oldoffset = offset;
gottrace = 1;
done = 0;
ntrace = 0;
noff = 0;
/* get DMO stretch/squeeze factors s1 and s2 */
stretchfactor (sdmo,gamma,&s1,&s2);
if(flip) {
temps = s1;
s1 = s2;
s2 = temps;
}
/* print useful information if requested */
if (verbose)fprintf(stderr,"stretching factors: s1=%f s2=%f\n",s1,s2);
/* loop over traces */
do {
/* if got a trace, determine offset */
if (gottrace) offset = tr.offset;
/* if an offset is complete */
if ((gottrace && offset!=oldoffset) || !gottrace) {
/* do dmo for old common-offset gather */
dmooff(oldoffset,fmax,nx,dx,nt,dt,ft,vrms,p,
gamma,boh,zoh,ntable,s1,s2,sign);
/* add dmo-corrected traces to mix */
for (ix=0; ix<nx; ++ix)
for (it=0; it<nt; ++it)
q[ix][it] += p[ix][it];
/* count offsets in mix */
noff++;
/* free space for old common-offset gather */
free2float(p);
/* if beginning a new offset */
if (offset!=oldoffset) {
/* allocate space for new offset */
nxpad = 0.5*ABS(offset/dx);
nxfft = npfar(nx+nxpad);
p = ealloc2float(nt,nxfft+2);
for (ix=0; ix<nxfft; ++ix)
for (it=0; it<nt; ++it)
p[ix][it] = 0.0;
}
}
/* if a mix of offsets is complete */
if (noff==noffmix || !gottrace) {
/* rewind trace header file */
efseeko(hfp, (off_t) 0,SEEK_SET);
/* loop over all output traces */
for (itrace=0; itrace<ntrace; ++itrace) {
/* read trace header and determine cdp index */
efread(&tro,HDRBYTES,1,hfp);
/* get dmo-corrected data */
memcpy((void *) tro.data,
(const void *) q[tro.cdp-cdpmin],
nt*sizeof(float));
/* write output trace */
puttr(&tro);
}
/* report */
if (verbose)
fprintf(stderr,"\tCompleted mix of "
"%d offsets with %d traces\n",
noff,ntrace);
/* if no more traces, break */
if (!gottrace) break;
/* rewind trace header file */
efseeko(hfp, (off_t) 0,SEEK_SET);
/* reset number of offsets and traces in mix */
noff = 0;
ntrace = 0;
/* zero offset mix accumulator */
for (ix=0; ix<nx; ++ix)
for (it=0; it<nt; ++it)
q[ix][it] = 0.0;
}
/* if cdp is within range to process */
if (tr.cdp>=cdpmin && tr.cdp<=cdpmax) {
/* save trace header and update number of traces */
efwrite(&tr,HDRBYTES,1,hfp);
ntrace++;
/* remember offset */
oldoffset = offset;
/* get trace samples */
memcpy((void *) p[tr.cdp-cdpmin],
(const void *) tr.data, nt*sizeof(float));
}
/* get next trace (if there is one) */
if (!gettr(&tr)) gottrace = 0;
} while (!done);
return(CWP_Exit());
}
int
main (int argc, char **argv)
{
int n1,n2,n1tic,n2tic,nfloats,bbox[4],
i1,i2,grid1,grid2,style,
n1c,n2c,n1s,n2s,i1beg,i1end,i2beg,i2end,i1c,i2c,
nz,iz,i1step,i2step,verbose,hls,bps,
legend,ugrid=SOLID,lstyle=VERTLEFT,lz,lbegsup=0,lendsup=0,ln=256,
lbbox[4], threecolor=0; /* BEREND, Schoenfelder */
int lnice; /* c liner */
float labelsize,titlesize,perc,clip,bperc,wperc,bclip,wclip,
d1,f1,d2,f2,*z,*temp,zscale,zoffset,zi,
xbox,ybox,width,height,
x1beg,x1end,x2beg,x2end,
x1min,x1max,x2min,x2max,
d1num,f1num,d2num,f2num,
p1beg,p1end,p2beg,p2end,matrix[6],colors[3][3], /* for 3 color mode */
d1s,d2s,
lwidth,lheight,lx,ly,lbeg,lend,lmin=(float) FLT_MAX,lmax=(float) -FLT_MAX,
ldnum,lfnum,ld,lf=0,labmatrix[6]; /* BEREND, Schoenfelder */
float axeswidth, ticwidth, gridwidth;
unsigned char *cz,*czp,*sz,*data_legend=NULL;
char *label1="",*label2="",*title="",*units="",
*legendfont="times_roman10",
*labelfont="Helvetica",*titlefont="Helvetica-Bold",
*styles="seismic",*grid1s="none",*grid2s="none",
*titlecolor="black",*axescolor="black",*gridcolor="black",
*lstyles="vertleft",*lgrids="none";
FILE *infp=stdin;
float **x1curve=NULL,**x2curve=NULL,*curvewidth=NULL;
int i,j,curve=0,*npair=NULL,ncurvecolor=0,ncurvewidth=0,ncurvedash=0,*curvedash=NULL;
char **curvecolor=NULL,**curvefile=NULL;
FILE *curvefp=NULL;
cwp_Bool is_curve = cwp_false;
/* initialize getpar */
initargs(argc,argv);
requestdoc(1);
/* get parameters describing 1st dimension sampling */
if (!getparint("n1",&n1)) err("must specify n1!\n");
d1 = 1.0; getparfloat("d1",&d1);
f1 = 0.0; getparfloat("f1",&f1);
x1min = (d1>0.0)?f1:f1+(n1-1)*d1;
x1max = (d1<0.0)?f1:f1+(n1-1)*d1;
/* get parameters describing 2nd dimension sampling */
if (!getparint("n2",&n2)) {
if (efseeko(infp,(off_t) 0,SEEK_END)!=0)
err("must specify n2 if in a pipe!\n");
nfloats = (int) (eftello(infp)/((off_t) sizeof(float)));
efseeko(infp,(off_t) 0,SEEK_SET);
n2 = nfloats/n1;
}
d2 = 1.0; getparfloat("d2",&d2);
f2 = 0.0; getparfloat("f2",&f2);
x2min = (d2>0.0)?f2:f2+(n2-1)*d2;
x2max = (d2<0.0)?f2:f2+(n2-1)*d2;
/* read color parameters */
if (!getparint("threecolor",&threecolor)) threecolor=1;
bps = 8;
hls = 0;
/* color[][0] is black, color[][2] is white in 2 color mode */
colors[R][0] = colors[G][0] = colors[B][0] = 0.0;
colors[R][1] = colors[G][1] = colors[B][1] = 0.5;
colors[R][2] = colors[G][2] = colors[B][2] = 1.0;
if (countparval("brgb") || countparval("wrgb")) {
float brgb[3],grgb[3],wrgb[3];
brgb[R] = brgb[G] = brgb[B] = 0.0;
wrgb[R] = wrgb[G] = wrgb[B] = 1.0;
getparfloat("brgb",&brgb[0]);
getparfloat("wrgb",&wrgb[0]);
grgb[R] = (brgb[R] + wrgb[R])/2.;
grgb[G] = (brgb[G] + wrgb[G])/2.;
grgb[B] = (brgb[B] + wrgb[B])/2.;
if (threecolor==1)
getparfloat("grgb",&grgb[0]);
brgb[R] = MAX(0.0,MIN(1.0,brgb[R]));
grgb[R] = MAX(0.0,MIN(1.0,grgb[R]));
wrgb[R] = MAX(0.0,MIN(1.0,wrgb[R]));
brgb[G] = MAX(0.0,MIN(1.0,brgb[G]));
grgb[G] = MAX(0.0,MIN(1.0,grgb[G]));
wrgb[G] = MAX(0.0,MIN(1.0,wrgb[G]));
brgb[B] = MAX(0.0,MIN(1.0,brgb[B]));
grgb[B] = MAX(0.0,MIN(1.0,grgb[B]));
wrgb[B] = MAX(0.0,MIN(1.0,wrgb[B]));
colors[R][0] = brgb[R]; colors[R][1] = grgb[R]; colors[R][2] = wrgb[R];
colors[G][0] = brgb[G]; colors[G][1] = grgb[G]; colors[G][2] = wrgb[G];
colors[B][0] = brgb[B]; colors[B][1] = grgb[B]; colors[B][2] = wrgb[B];
if (!getparint("bps",&bps)) bps = 12;
if (bps!=12 && bps!=24)
err("bps must equal 12 or 24 for color plots!\n");
} else if (countparval("bhls") || countparval("whls")) {
float bhls[3],ghls[3],whls[3];
hls = 1;
bhls[H] = ghls[H] = whls[H] = 0.0;
bhls[L] = 0.0; ghls[L] = 0.5; whls[L] = 1.0;
bhls[S] = ghls[S] = whls[S] = 0.0;
getparfloat("bhls",&bhls[0]);
getparfloat("whls",&whls[0]);
ghls[H] = (bhls[H] + whls[H])/2.;
ghls[L] = (bhls[L] + whls[L])/2.;
ghls[S] = (bhls[S] + whls[S])/2.;
if (threecolor==1)
getparfloat("ghls",&ghls[0]);
bhls[L] = MAX(0.0,MIN(1.0,bhls[L]));
ghls[L] = MAX(0.0,MIN(1.0,ghls[L]));
whls[L] = MAX(0.0,MIN(1.0,whls[L]));
bhls[S] = MAX(0.0,MIN(1.0,bhls[S]));
ghls[S] = MAX(0.0,MIN(1.0,ghls[S]));
whls[S] = MAX(0.0,MIN(1.0,whls[S]));
colors[H][0] = bhls[0]; colors[H][1] = ghls[0]; colors[H][2] = whls[0];
colors[L][0] = bhls[1]; colors[L][1] = ghls[1]; colors[L][2] = whls[1];
colors[S][0] = bhls[2]; colors[S][1] = ghls[2]; colors[S][2] = whls[2];
if (!getparint("bps",&bps)) bps = 12;
if (bps!=12 && bps!=24)
err("bps must equal 12 or 24 for color plots!\n");
}
/* get legend specs BEREND, Schoenfelder */
legend = 0; getparint("legend", &legend); /* BEREND, Schoenfelder */
getparstring("units", &units); /* BEREND, Schoenfelder */
getparstring("legendfont", &legendfont); /* BEREND, Schoenfelder */
/* set up curve plotting */
if ((curve=countparval("curve"))!=0) {
curvefile=(char**)ealloc1(curve,sizeof(void*));
getparstringarray("curve",curvefile);
if ((x1curve=(float**)malloc(curve*sizeof(void*)))==NULL)
err("Could not allocate x1curve pointers\n");
if ((x2curve=(float**)malloc(curve*sizeof(void*)))==NULL)
err("Could not allocate x2curve pointers\n");
npair=ealloc1int(curve);
getparint("npair",npair);
is_curve = cwp_true;
} else {
npair=(int *)NULL;
curvefile=(char **)NULL;
x1curve=(float **)NULL;
x2curve=(float **)NULL;
is_curve = cwp_false;
}
if (is_curve) {
if ((ncurvecolor=countparval("curvecolor"))<curve) {
curvecolor=(char**)ealloc1(curve,sizeof(void*));
if (!getparstringarray("curvecolor",curvecolor)) {
curvecolor[0]=(char *)cwp_strdup("black\0");
ncurvecolor=1;
}
for (i=ncurvecolor; i<curve; i++)
curvecolor[i]=(char *)cwp_strdup(curvecolor[ncurvecolor-1]);
} else if (ncurvecolor) {
curvecolor=(char**)ealloc1(ncurvecolor,sizeof(void*));
getparstringarray("curvecolor",curvecolor);
}
for (j=0; j<curve; j++) {
curvefp=efopen(curvefile[j],"r");
x1curve[j]=ealloc1float(npair[j]);
x2curve[j]=ealloc1float(npair[j]);
for (i=0; i<npair[j]; i++) {
fscanf(curvefp,"%f",&x1curve[j][i]);
fscanf(curvefp,"%f",&x2curve[j][i]);
}
efclose(curvefp);
}
}
/* read binary data to be plotted */
nz = n1*n2;
z = ealloc1float(nz);
if (fread(z,sizeof(float),nz,infp)!=nz)
err("error reading input file!\n");
/* if necessary, determine clips from percentiles */
if (getparfloat("clip",&clip)) {
bclip = clip;
wclip = -clip;
}
if ((!getparfloat("bclip",&bclip) || !getparfloat("wclip",&wclip)) &&
!getparfloat("clip",&clip)) {
perc = 100.0; getparfloat("perc",&perc);
temp = ealloc1float(nz);
for (iz=0; iz<nz; iz++)
temp[iz] = z[iz];
if (!getparfloat("bclip",&bclip)) {
bperc = perc; getparfloat("bperc",&bperc);
iz = (nz*bperc/100.0);
if (iz<0) iz = 0;
if (iz>nz-1) iz = nz-1;
qkfind(iz,nz,temp);
bclip = temp[iz];
}
if (!getparfloat("wclip",&wclip)) {
wperc = 100.0-perc; getparfloat("wperc",&wperc);
iz = (nz*wperc/100.0);
if (iz<0) iz = 0;
if (iz>nz-1) iz = nz-1;
qkfind(iz,nz,temp);
wclip = temp[iz];
}
free1float(temp);
}
verbose = 1; getparint("verbose",&verbose);
if (verbose) warn("bclip=%g wclip=%g",bclip,wclip);
/* get scaled sampling intervals */
d1s = 1.0; getparfloat("d1s",&d1s);
d2s = 1.0; getparfloat("d2s",&d2s);
d1s = fabs(d1s); d1s *= d1;
d2s = fabs(d2s); d2s *= d2;
/* get axes parameters */
xbox = 1.5; getparfloat("xbox",&xbox); /* if psimage is called by ximage, it */
ybox = 1.5; getparfloat("ybox",&ybox); /* will xbox=1.166 and ybox=1.167 */
width = 6.0; getparfloat("wbox",&width); getparfloat("width",&width);
height = 8.0;getparfloat("hbox",&height);getparfloat("height",&height);
/* begin c liner */
lnice = 0; getparint("lnice",&lnice);
if (lnice==1) {
ybox = 2.2;
/* lx=8 is set below, after getpar on lx ... c liner */
width = 5.4;
height = 7.2;
}
/* end c liner */
x1beg = x1min; getparfloat("x1beg",&x1beg);
x1end = x1max; getparfloat("x1end",&x1end);
d1num = 0.0; getparfloat("d1num",&d1num);
f1num = x1min; getparfloat("f1num",&f1num);
n1tic = 1; getparint("n1tic",&n1tic);
getparstring("grid1",&grid1s);
if (STREQ("dot",grid1s))
grid1 = DOT;
else if (STREQ("dash",grid1s))
grid1 = DASH;
else if (STREQ("solid",grid1s))
grid1 = SOLID;
else
grid1 = NONE;
getparstring("label1",&label1);
x2beg = x2min; getparfloat("x2beg",&x2beg);
x2end = x2max; getparfloat("x2end",&x2end);
d2num = 0.0; getparfloat("d2num",&d2num);
f2num = 0.0; getparfloat("f2num",&f2num);
n2tic = 1; getparint("n2tic",&n2tic);
getparstring("grid2",&grid2s);
if (STREQ("dot",grid2s))
grid2 = DOT;
else if (STREQ("dash",grid2s))
grid2 = DASH;
else if (STREQ("solid",grid2s))
grid2 = SOLID;
else
grid2 = NONE;
getparstring("label2",&label2);
getparstring("labelfont",&labelfont);
labelsize = 18.0; getparfloat("labelsize",&labelsize);
getparstring("title",&title);
getparstring("titlefont",&titlefont);
titlesize = 24.0; getparfloat("titlesize",&titlesize);
getparstring("titlecolor",&titlecolor);
getparstring("axescolor",&axescolor);
getparstring("gridcolor",&gridcolor);
/* axes and tic width */
if(!getparfloat("axeswidth",&axeswidth)) axeswidth=1;
if (!getparfloat("ticwidth",&ticwidth)) ticwidth=axeswidth;
if(!getparfloat("gridwidth",&gridwidth)) gridwidth =axeswidth;
if (is_curve) {
if ((ncurvewidth=countparval("curvewidth"))<curve) {
curvewidth=ealloc1float(curve);
if (!getparfloat("curvewidth",curvewidth)) {
curvewidth[0]=axeswidth;
ncurvewidth=1;
}
for (i=ncurvewidth; i<curve; i++)
curvewidth[i]=curvewidth[ncurvewidth-1];
} else {
curvewidth=ealloc1float(ncurvewidth);
getparfloat("curvewidth",curvewidth);
}
if ((ncurvedash=countparval("curvedash"))<curve) {
curvedash=ealloc1int(curve);
if (!getparint("curvedash",curvedash)) {
curvedash[0]=0;
ncurvedash=1;
}
for (i=ncurvedash; i<curve; i++)
curvedash[i]=curvedash[ncurvedash-1];
} else {
curvedash=ealloc1int(ncurvedash);
getparint("curvedash",curvedash);
}
}
getparstring("style",&styles);
if (STREQ("normal",styles))
style = NORMAL;
else
style = SEISMIC;
/* Get or calc legend parameters */
/* Legend min and max: Calc from data read in */
if (legend) {
for (lz=0;lz<nz;lz++) {
lmin=FMIN(lmin,z[lz]);
lmax=FMAX(lmax,z[lz]);
}
if (verbose==2) warn("lmin=%g lmax=%g",lmin,lmax);
}
if (legend) {
lbeg = lmin; if (getparfloat("lbeg",&lbeg)) lbegsup=1;
lend = lmax; if (getparfloat("lend",&lend)) lendsup=1;
/* Change wclip,bclip to be inside legend range */
wclip = FMAX(lbeg,wclip); /* [wclip,bclip] has to be in [lbeg,lend] */
bclip = FMIN(lend,bclip);
if (lbegsup!=1) { /* Add white and black areas to show possible clipping */
float rangeperc=(bclip-wclip)/20.;
lbeg=wclip-rangeperc;
}
if (lendsup!=1) {
float rangeperc=(bclip-wclip)/20.;
lend=bclip+rangeperc;
}
lfnum = lmin; getparfloat("lfnum",&lfnum);
getparstring("lstyle",&lstyles);
if (STREQ("vertright",lstyles))
lstyle = VERTRIGHT;
else if (STREQ("horibottom",lstyles))
lstyle = HORIBOTTOM;
/* legend dimensions (BEREND), Schoenfelder */
lwidth = 0.1 ;lheight = height/2;
if (lstyle==HORIBOTTOM) {
lwidth=width/1.2 ;lheight = 0.24;
}
getparfloat("lwidth",&lwidth);
getparfloat("lheight",&lheight);
lx=.8;ly = ybox+(height-lheight)/2;
if (lstyle==VERTRIGHT) {
lx=xbox+width+0.1;
} else if (lstyle==HORIBOTTOM) {
lx=xbox+(width-lwidth)/2.0;ly = 1.0;
}
getparfloat("lx",&lx);
if (lnice==1) lx = 8; /* c liner */
getparfloat("ly",&ly);
getparstring("lgrid",&lgrids);
if (STREQ("dot",lgrids))
ugrid = DOT;
else if (STREQ("dash",lgrids))
ugrid = DASH;
else if (STREQ("solid",lgrids))
ugrid = SOLID;
else
ugrid = NONE;
}
/* adjust x1beg and x1end to fall on sampled values */
/* This will not allow to display an area greater than the data supplied */
i1beg = NINT((x1beg-f1)/d1);
i1beg = MAX(0,MIN(n1-1,i1beg));
x1beg = f1+i1beg*d1;
i1end = NINT((x1end-f1)/d1);
i1end = MAX(0,MIN(n1-1,i1end));
x1end = f1+i1end*d1;
/* adjust x2beg and x2end to fall on sampled values */
i2beg = NINT((x2beg-f2)/d2);
i2beg = MAX(0,MIN(n2-1,i2beg));
x2beg = f2+i2beg*d2;
i2end = NINT((x2end-f2)/d2);
i2end = MAX(0,MIN(n2-1,i2end));
x2end = f2+i2end*d2;
if (legend) {
/* Make legend color values */
int lll=0,lcount,perc5=13,ilbeg,ilend; /* color scale */
if (lbegsup!=1) {
ln+=perc5; /* white area */
}
if (lendsup!=1) {
ln+=perc5; /* black area */
}
data_legend = ealloc1(ln,sizeof(char));
if (lbegsup!=1) {
for (lll=0;lll<perc5;lll++) data_legend[lll]=(char) 255; /* white area */
}
for (lcount=255;lcount>=0;lcount--,lll++) data_legend[lll]=(char) lcount;
if (lendsup!=1) {
for (;lll<ln;lll++) data_legend[lll]=(char) 0; /* black area */
}
lf=lbeg;ld=(lend-lbeg)/(ln-1);
if (!(getparfloat("ldnum",&ldnum))) ldnum=0.0;
/* adjust lbeg and lend to fall on sampled values */
ilbeg = NINT((lbeg-lf)/ld);
ilbeg = MAX(0,MIN(ln-1,ilbeg));
lbeg = lf+ilbeg*ld;
ilend = NINT((lend-lf)/ld);
ilend = MAX(0,MIN(ln-1,ilend));
lend = lf+ilend*ld;
}
/* allocate space for image bytes */
n1c = 1+abs(i1end-i1beg);
n2c = 1+abs(i2end-i2beg);
cz = ealloc1(n1c*n2c,sizeof(char));
/* convert data to be imaged into unsigned characters */
zscale = (wclip!=bclip)?255.0/(wclip-bclip):1.0e10;
zoffset = -bclip*zscale;
i1step = (i1end>i1beg)?1:-1;
i2step = (i2end>i2beg)?1:-1;
czp = cz;
for (i1c=0,i1=i1beg; i1c<n1c; i1c++,i1+=i1step) {
for (i2c=0,i2=i2beg; i2c<n2c; i2c++,i2+=i2step) {
zi = zoffset+z[i1+i2*n1]*zscale;
if (zi<0.0) zi = 0.0;
if (zi>255.0) zi = 255.0;
*czp++ = (unsigned char)zi;
}
}
free1float(z);
/* determine sampling after scaling */
n1s = MAX(1,NINT(1+(n1c-1)*d1/d1s));
d1s = (n1s>1)?d1*(n1c-1)/(n1s-1):d1;
n2s = MAX(1,NINT(1+(n2c-1)*d2/d2s));
d2s = (n2s>1)?d2*(n2c-1)/(n2s-1):d2;
/* if necessary, interpolate to scaled sampling intervals */
if (n1s!=n1c || n2s!=n2c) {
sz = ealloc1(n1s*n2s,sizeof(char));
intl2b(n2c,d2,0.0,n1c,d1,0.0,cz,n2s,d2s,0.0,n1s,d1s,0.0,sz); /* Interpol array */
free1(cz);
} else {
sz = cz;
}
/* determine axes pads */
p1beg = (x1end>x1beg)?-fabs(d1s)/2:fabs(d1s)/2;
p1end = (x1end>x1beg)?fabs(d1s)/2:-fabs(d1s)/2;
p2beg = (x2end>x2beg)?-fabs(d2s)/2:fabs(d2s)/2;
p2end = (x2end>x2beg)?fabs(d2s)/2:-fabs(d2s)/2;
/* convert axes box parameters from inches to points */
xbox *= 72.0;
ybox *= 72.0;
width *= 72.0;
height *= 72.0;
if (legend) {
lx *= 72.0; /* Schoenfelder */
ly *= 72.0; /* Schoenfelder */
lwidth *= 72.0; /* Schoenfelder */
lheight *= 72.0; /* Schoenfelder */
}
/* set bounding box */
psAxesBBox(
xbox,ybox,width,height,
labelfont,labelsize,
titlefont,titlesize,
style,bbox);
if (legend) {
psLegendBBox( /* Space for legend Schoenfelder */
lx,ly,lwidth,lheight,
labelfont,labelsize,
lstyle,lbbox);
/* Include space for legend Schoenfelder */
bbox[0]=MIN(bbox[0],lbbox[0]);
bbox[1]=MIN(bbox[1],lbbox[1]);
bbox[2]=MAX(bbox[2],lbbox[2]);
bbox[3]=MAX(bbox[3],lbbox[3]);
}
boundingbox(bbox[0],bbox[1],bbox[2],bbox[3]);
/* begin PostScript */
begineps();
/* save graphics state */
gsave();
/* translate coordinate system by box offset */
translate(xbox,ybox);
/* determine image matrix */
if (style==NORMAL) {
matrix[0] = 0; matrix[1] = n1s; matrix[2] = n2s;
matrix[3] = 0; matrix[4] = 0; matrix[5] = 0;
} else {
matrix[0] = n2s; matrix[1] = 0; matrix[2] = 0;
matrix[3] = -n1s; matrix[4] = 0; matrix[5] = n1s;
}
scale(width,height);
/* draw the image (before axes so grid lines are visible) */
drawimage(hls,colors,n2s,n1s,bps,matrix,sz);
/***************************/
/* main image has been drawn, restore graphics state */
grestore();
/* *********************************/
/* draw the colorbar (before axes so grid lines are visible) Schoenfelder*/
if (legend) {
gsave();
translate(lx,ly);
scale(lwidth,lheight);
if ((lstyle==VERTLEFT) || (lstyle==VERTRIGHT)) {
labmatrix[0] = 1; labmatrix[1] = 0; labmatrix[2] = 0;
labmatrix[3] = ln; labmatrix[4] = 0; labmatrix[5] = 0;
drawimage(hls,colors,1,ln,bps,labmatrix,data_legend);
} else {
labmatrix[0] = -1; labmatrix[1] = 0; labmatrix[2] = 0;
labmatrix[3] = ln; labmatrix[4] = 0; labmatrix[5] = 0;
rotate(-90);
drawimage(hls,colors,1,ln,bps,labmatrix,data_legend);
rotate(90);
}
grestore();
}
/* draw curve */
for (i=0; i<curve; i++) {
gsave();
psDrawCurve(
xbox,ybox,width,height,
x1beg,x1end,p1beg,p1end,
x2beg,x2end,p2beg,p2end,
x1curve[i],x2curve[i],npair[i],
curvecolor[i],curvewidth[i],curvedash[i],style);
grestore();
}
gsave();
/* draw axes and title */
psAxesBox(
xbox,ybox,width,height,
x1beg,x1end,p1beg,p1end,
d1num,f1num,n1tic,grid1,label1,
x2beg,x2end,p2beg,p2end,
d2num,f2num,n2tic,grid2,label2,
labelfont,labelsize,
title,titlefont,titlesize,
titlecolor,axescolor,gridcolor,
ticwidth,axeswidth,gridwidth,
style);
/* restore graphics state */
grestore();
/* draw axes and title for legend Schoenfelder*/
if (legend) {
float lpbeg,lpend;
int lntic=1;
gsave();
lpbeg = 0.0; /*(lend>lbeg)?-fabs(d1s)/2:fabs(d1s)/2;*/
lpend = 0.0; /*(lend>lbeg)?fabs(d1s)/2:-fabs(d1s)/2;*/
psLegendBox(
lx,ly,lwidth,lheight,
lbeg,lend,lpbeg,lpend,
ldnum,lf,lntic,ugrid,units,
labelfont,labelsize,
axescolor,gridcolor,
lstyle);
grestore();
}
/* end PostScript */
showpage();
endeps();
if (curve) {
free1int(npair);
for (i=0; i<curve; i++) {
free1float(x1curve[i]);
free1float(x2curve[i]);
}
free1float(curvewidth);
free1int(curvedash);
free((void**)x1curve);
free((void**)x2curve);
free((void**)curvefile);
free((void**)curvecolor);
}
return 0;
}
