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; }