void load_sprites( unsigned int table, FILE *f )
{
free_sprites(table);
Uint16 temp;
efread(&temp, sizeof(Uint16), 1, f);
sprite_table[table].count = temp;
for (unsigned int i = 0; i < sprite_table[table].count; ++i)
{
Sprite * const cur_sprite = sprite(table, i);
if (!getc(f)) // sprite is empty
continue;
efread(&cur_sprite->width, sizeof(Uint16), 1, f);
efread(&cur_sprite->height, sizeof(Uint16), 1, f);
efread(&cur_sprite->size, sizeof(Uint16), 1, f);
cur_sprite->data = malloc(cur_sprite->size);
efread(cur_sprite->data, sizeof(Uint8), cur_sprite->size, f);
}
}
void intp3(FILE *fp, float *p1, float *p2, float *p3, float *p4, float *po,
float o1, float d1, int n1, int n2,
int i21, int i22, int i31, int i32,
float w21, float w22, float w31, float w32) {
long lpos;
int i1;
lpos = i21+i31*n2;
lpos = lpos*n1*4;
fseek2g(fp,lpos,0);
efread(p1,sizeof(float),n1,fp);
lpos = i22+i31*n2;
lpos = lpos*n1*4;
fseek2g(fp,lpos,0);
efread(p2,sizeof(float),n1,fp);
lpos = i21+i32*n2;
lpos = lpos*n1*4;
fseek2g(fp,lpos,0);
efread(p3,sizeof(float),n1,fp);
lpos = i22+i32*n2;
lpos = lpos*n1*4;
fseek2g(fp,lpos,0);
efread(p4,sizeof(float),n1,fp);
for(i1=0;i1<n1;i1++) {
po[i1] = (p1[i1]*w21 + p2[i1]*w22)*w31 +
(p3[i1]*w21 + p4[i1]*w22)*w32;
}
}
void JE_loadSong( JE_word songnum )
{
JE_word x;
FILE *fi, *test;
JE_resetFile(&fi, "music.mus");
if (notYetLoadedMusic)
{
/* SYN: We're loading offsets into MUSIC.MUS for each song here. */
notYetLoadedMusic = false;
efread(&x, sizeof(x), 1, fi);
efread(songPos, sizeof(JE_longint), sizeof(songPos) / sizeof(JE_longint), fi); /* SYN: reads long int (i.e. 4) * MUSICNUM */
fseek(fi, 0, SEEK_END);
songPos[MUSIC_NUM] = ftell(fi); /* Store file size */
}
/* SYN: Now move to the start of the song we want, and load the number of bytes given by the
difference in offsets between it and the next song. */
fseek(fi, songPos[songnum - 1], SEEK_SET);
efread(&musicData, 1, songPos[songnum] - songPos[songnum - 1], fi);
/* currentSong = songnum; */
fclose(fi);
}
void JE_loadPic(SDL_Surface *screen, uint8_t PCXnumber, bool storepal )
{
PCXnumber--;
FILE *f = dir_fopen_die(data_dir(), "tyrian.pic", "rb");
static bool first = true;
if (first)
{
first = false;
uint16_t temp;
efread(&temp, sizeof(uint16_t), 1, f);
for (int i = 0; i < PCX_NUM; i++)
{
efread(&pcxpos[i], sizeof(int32_t), 1, f);
}
pcxpos[PCX_NUM] = ftell_eof(f);
}
uint32_t size = pcxpos[PCXnumber + 1] - pcxpos[PCXnumber];
uint8_t *buffer = malloc(size);
fseek(f, pcxpos[PCXnumber], SEEK_SET);
efread(buffer, sizeof(uint8_t), size, f);
fclose(f);
uint8_t *p = buffer;
uint8_t *s; /* screen pointer, 8-bit specific */
s = (uint8_t *)screen->pixels;
for (int i = 0; i < 320 * 200; )
{
if ((*p & 0xc0) == 0xc0)
{
i += (*p & 0x3f);
memset(s, *(p + 1), (*p & 0x3f));
s += (*p & 0x3f); p += 2;
} else {
i++;
*s = *p;
s++; p++;
}
if (i && (i % 320 == 0))
{
s += screen->pitch - 320;
}
}
free(buffer);
memcpy(colors, palettes[pcxpal[PCXnumber]], sizeof(colors));
if (storepal)
set_palette(colors, 0, 255);
}
void JE_loadMainShapeTables( const char *shpfile )
{
#ifdef TYRIAN2000
const int SHP_NUM = 13;
#else
const int SHP_NUM = 12;
#endif
FILE *f = dir_fopen_die(data_dir(), shpfile, "rb");
JE_word shpNumb;
JE_longint shpPos[SHP_NUM + 1]; // +1 for storing file length
efread(&shpNumb, sizeof(JE_word), 1, f);
assert(shpNumb + 1u == COUNTOF(shpPos));
for (unsigned int i = 0; i < shpNumb; ++i)
efread(&shpPos[i], sizeof(JE_longint), 1, f);
fseek(f, 0, SEEK_END);
for (unsigned int i = shpNumb; i < COUNTOF(shpPos); ++i)
shpPos[i] = ftell(f);
int i;
// fonts, interface, option sprites
for (i = 0; i < 7; i++)
{
fseek(f, shpPos[i], SEEK_SET);
load_sprites(i, f);
}
// player shot sprites
shapesC1.size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&shapesC1, f);
i++;
// player ship sprites
shapes9.size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&shapes9 , f);
i++;
// power-up sprites
eShapes[5].size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&eShapes[5], f);
i++;
// coins, datacubes, etc sprites
eShapes[4].size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&eShapes[4], f);
i++;
// more player shot sprites
shapesW2.size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&shapesW2, f);
fclose(f);
}
void JE_loadMainShapeTables( const char *shpfile )
{
const int SHP_NUM = 12;
FILE *f = dir_fopen_die(data_dir(), shpfile, "rb");
JE_word shpNumb;
JE_longint shpPos[SHP_NUM + 1]; // +1 for storing file length
efread(&shpNumb, sizeof(JE_word), 1, f);
assert(shpNumb + 1 <= COUNTOF(shpPos));
for (int i = 0; i < shpNumb; i++)
{
efread(&shpPos[i], sizeof(JE_longint), 1, f);
}
fseek(f, 0, SEEK_END);
shpPos[shpNumb] = ftell(f);
int i;
// fonts, interface, option sprites
for (i = 0; i < 7; i++)
{
fseek(f, shpPos[i], SEEK_SET);
load_sprites(i, f);
}
// player shot sprites
shapesC1.size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&shapesC1, f);
i++;
// player ship sprites
shapes9.size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&shapes9 , f);
i++;
// power-up sprites
eShapes6.size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&eShapes6, f);
i++;
// coins, datacubes, etc sprites
eShapes5.size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&eShapes5, f);
i++;
// more player shot sprites
shapesW2.size = shpPos[i + 1] - shpPos[i];
JE_loadCompShapesB(&shapesW2, f);
fclose(f);
}
void JE_analyzeLevel( void )
{
FILE *f = dir_fopen_die(data_dir(), levelFile, "rb");
efread(&lvlNum, sizeof(JE_word), 1, f);
for (int x = 0; x < lvlNum; x++)
efread(&lvlPos[x], sizeof(JE_longint), 1, f);
lvlPos[lvlNum] = ftell_eof(f);
fclose(f);
}
void load_music( void )
{
if (music_file == NULL)
{
music_file = dir_fopen_die(data_dir(), "music.mus", "rb");
efread(&song_count, sizeof(song_count), 1, music_file);
song_offset = malloc((song_count + 1) * sizeof(song_offset));
efread(song_offset, 4, song_count, music_file);
song_offset[song_count] = ftell_eof(music_file);
}
}
void JE_analyzeLevel( void )
{
JE_word x;
FILE *f;
JE_resetFile(&f, levelFile);
efread(&lvlNum, sizeof(JE_word), 1, f);
for (x = 0; x < lvlNum; x++)
{
efread(&lvlPos[x], sizeof(JE_longint), 1, f);
}
fseek(f, 0, SEEK_END);
lvlPos[lvlNum] = ftell(f);
fclose(f);
}
void JE_loadCompShapesB( Sprite2_array *sprite2s, FILE *f )
{
free_sprite2s(sprite2s);
sprite2s->data = malloc(sizeof(Uint8) * sprite2s->size);
efread(sprite2s->data, sizeof(Uint8), sprite2s->size, f);
}
void fputdata(FILE *fileptr, FILE *headerptr, float *outdata, int nt)
{
efread(&tr, 1, HDRBYTES, headerptr);
erewind(headerptr);
memcpy((void *)tr.data, (const void *) outdata, nt*FSIZE);
fputtr(fileptr, &tr);
}
/* Loads the given page into memory.
*
* Returns 0 on success or nonzero on failure (bad data)
*/
int JE_loadPage( uint32_t pagenumber )
{
uint32_t i, pageSize;
if (Curlpnum == pagenumber) { return(0); } /* Already loaded */
Curlpnum = pagenumber;
/* We need to seek to the page and load it into our buffer.
* Pages have a fixed size of 0x10000; any left over space is padded
* unless it's the end of the file.
*
* Pages repeat their headers for some reason. They then have two bytes of
* padding folowed by a word for every record. THEN the data starts.
*/
fseek(InFile, ANIM_OFFSET + (pagenumber * ANI_PAGE_SIZE), SEEK_SET);
efread(&CurrentPageHeader.baseRecord, 2, 1, InFile);
efread(&CurrentPageHeader.nRecords, 2, 1, InFile);
efread(&CurrentPageHeader.nBytes, 2, 1, InFile);
fseek(InFile, 2, SEEK_CUR);
for (i = 0; i < CurrentPageHeader.nRecords; i++)
{
efread(&CurrentPageRecordSizes[i], 2, 1, InFile);
}
/* What remains is the 'compressed' data */
efread(CurrentPageBuffer, 1, CurrentPageHeader.nBytes, InFile);
/* Okay, we've succeeded in all our IO checks. Now, make sure the
* headers aren't lying or damaged or something.
*/
pageSize = 0;
for (i = 0; i < CurrentPageHeader.nRecords; i++)
{
pageSize += CurrentPageRecordSizes[i];
}
if(pageSize != CurrentPageHeader.nBytes) { return(-1); }
/* So far, so good */
return(0);
}
void JE_loadPCX( char *file ) // this is only meant to load tshp2.pcx
{
FILE *f;
Uint8 *s = VGAScreen->pixels; /* 8-bit specific */
JE_resetFile(&f, file);
fseek(f, -769, SEEK_END);
if (fgetc(f) == 12)
{
for (int i = 0; i < 256; i++)
{
efread(&colors[i].r, 1, 1, f);
efread(&colors[i].g, 1, 1, f);
efread(&colors[i].b, 1, 1, f);
}
}
fseek(f, 128, SEEK_SET);
for (int i = 0; i < 320 * 200; )
{
Uint8 p = fgetc(f);
if ((p & 0xc0) == 0xc0)
{
i += (p & 0x3f);
memset(s, fgetc(f), (p & 0x3f));
s += (p & 0x3f);
} else {
i++;
*s = p;
s++;
}
if (i && (i % 320 == 0))
{
s += VGAScreen->pitch - 320;
}
}
fclose(f);
}
static
int dataread(struct insegyinfo *iptr, segy *tp, cwp_Bool fixed_length)
{
unsigned int nsread = fixed_length?iptr->nsfirst:tp->ns;
unsigned int databytes = infoptr->bytesper*nsread;
int nread;
int itest = 1;
char *ctest = (char *) (&itest);
/* read trace data */
switch(tp->trid) {
case CHARPACK:
nread = efread((char *) (&((tp->data)[0])),1,databytes,
iptr->infp);
case SHORTPACK:
nread = efread((char *) (&((tp->data)[0])),1,databytes,
iptr->infp);
if(ctest[0]) swab((char *) (&((tp->data)[0])),
(char *) (&((tp->data)[0])),
databytes);
break;
default:
nread = efread(((char *) (iptr->buf))+HDRBYTES,1,databytes,
iptr->infp);
if(nread != databytes || FALSE == xdr_vector(iptr->segy_xdr,
(char *) (&((tp->data)[0])),
nsread,sizeof(float),(xdrproc_t) xdr_float))
nread = 0;
else
nread = databytes;
break;
}
if(nread > 0 && nread != databytes)
err("%s: on trace #%ld, tried to read %d bytes, "
"read %d bytes",
__FILE__, (infoptr->itr)+1, databytes, nread);
return(nread);
}
void JE_loadPCX( const char *file ) // this is only meant to load tshp2.pcx
{
Uint8 *s = (Uint8 *)VGAScreen->pixels; /* 8-bit specific */
SDL_RWops *f = dir_fopen_die(data_dir(), file, "rb");
efseek(f, -769, SEEK_END);
if (efgetc(f) == 12)
{
for (int i = 0; i < 256; i++)
{
efread(f, &colors[i].r, 1, 1);
efread(f, &colors[i].g, 1, 1);
efread(f, &colors[i].b, 1, 1);
}
}
efseek(f, 128, SEEK_SET);
for (int i = 0; i < 320 * 200; )
{
Uint8 p = efgetc(f);
if ((p & 0xc0) == 0xc0)
{
i += (p & 0x3f);
memset(s, efgetc(f), (p & 0x3f));
s += (p & 0x3f);
} else {
i++;
*s = p;
s++;
}
if (i && (i % 320 == 0))
{
s += VGAScreen->pitch - 320;
}
}
efclose(f);
}
bool initauxtbl(char *aux) {
char *filename;
FILE * fp ;
int pflen, nread, pfargc, targc, i, j ;
char *argstr, **targv ;
if( !getnpar(0,aux,"s",&filename) ) {
fprintf(stderr,"Can't get auxiliary input %s definition\n",aux) ;
return 0 ;
}
fp = fopen(filename, "r") ;
if( fp == NULL ) {
fprintf(stderr,"Can't open auxiliary input file %s=%s\n",aux,filename);
return 0 ;
}
/* Get the length */
efseek(fp, 0, SEEK_END);
pflen = eftell(fp);
rewind(fp);
argstr = (char *) ealloc1(1+pflen+1, 1);
/* Read the parfile */
nread = efread(argstr+1, 1, pflen, fp);
if (nread != pflen) {
err("%s: fread only %d bytes out of %d from %s",
__FILE__,nread,pflen,filename);
}
efclose(fp);
/* Zap whites in parfile to help in parsing */
argstr[0] = '\0' ;
pfargc = white2null(argstr, pflen);
targc = pfargc ;
/* Allocate space for total arg pointers */
targv = (char **) ealloc1(targc, sizeof(char*));
/* Parse the parfile. Skip over multiple NULLs */
for( j=1, i=0; j < pflen; j++) {
if( argstr[j] && !argstr[j-1] ) {
targv[i++] = argstr + j;
}
}
/* Allocate space for the pointer table */
argtbl = (ArgStruct*) ealloc1(targc, sizeof(ArgStruct));
/* Tabulate targv */
tabulate(targc, targv);
return 1 ;
}
void fputdata3c(FILE *fileptr, FILE *headerptr, float **outdata3c, int nt)
{
int i;
for(i=1;i<=3;i++) {
efread(&tr, 1, HDRBYTES, headerptr);
memcpy((void *)tr.data, (const void *) outdata3c[i], nt*FSIZE);
fputtr(fileptr, &tr);
}
erewind(headerptr);
}
int
main(int argc, char **argv)
{
char *outpar; /* name of file holding output parfile */
FILE *outparfp; /* ... its file pointer */
int n1; /* number of floats per line */
size_t n1read; /* number of items read */
size_t n2 = 0; /* number of lines in input file */
float *z; /* binary floats */
/* Hook up getpar */
initargs(argc, argv);
requestdoc(1);
/* Get parameters and do set up */
if (!getparstring("outpar", &outpar)) outpar = "/dev/tty" ;
outparfp = efopen(outpar, "w");
MUSTGETPARINT("n1",&n1);
z = ealloc1float(n1);
/* Loop over data converting to ascii */
while ((n1read = efread(z, FSIZE, n1, stdin))) {
register int i1;
if (n1read != n1)
err("out of data in forming line #%d", n2+1);
for (i1 = 0; i1 < n1; ++i1)
/* z2xyz.c:70: warning: format ‘%d’ expects type ‘int’, but argument 2 has type ‘size_t’ */
/* printf("%d %d %11.4e \n",n2,i1,z[i1]); */
#if __WORDSIZE == 64
printf("%lu %d %11.4e \n",n2,i1,z[i1]);
#else
printf("%u %d %11.4e \n",n2,i1,z[i1]);
#endif
++n2;
}
/* Make par file */
/* z2xyz.c:76: warning: format ‘%d’ expects type ‘int’, but argument 3 has type ‘size_t’ */
/* fprintf(outparfp, "n2=%d\n", n2); */
#if __WORDSIZE == 64
fprintf(outparfp, "n2=%lu\n", n2);
#else
fprintf(outparfp, "n2=%u\n", n2);
#endif
return(CWP_Exit());
}
static
int dataread(segy *tp, struct insegyinfo *iptr, cwp_Bool fixed_length)
{
unsigned int nsread = fixed_length?iptr->nsfirst:tp->ns;
unsigned int databytes = infoptr->bytesper*nsread;
int nread = (int) efread((char *) (&((tp->data)[0])),1, databytes,
iptr->infp);
if(nread > 0 && nread != databytes)
err("%s: on trace #%ld, tried to read %d bytes, "
"read %d bytes ",
__FILE__, (infoptr->itr)+1, databytes, nread);
return(nread);
}
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());
}
void read_encrypted_pascal_string( char *s, int size, FILE *f )
{
int len = getc(f);
if (len != EOF)
{
int skip = MAX((len + 1) - size, 0);
assert(skip == 0);
len -= skip;
efread(s, 1, len, f);
if (size > 0)
s[len] = '\0';
fseek(f, skip, SEEK_CUR);
decrypt_pascal_string(s, len);
}
}
void
feeder(struct dpipe *source, struct FeederState *state)
{
if (!state->file || feof(state->file))
next_fragment(source, state);
if (state->file) {
{
char * const transfer = emalloc(BUFSIZ, WHERE(feeder));
const int count = efread(transfer, 1, BUFSIZ, state->file, WHERE(feeder));
if (count > 0)
dpipe_Put(source, transfer, count);
else
dpipe_Close(source);
}
} else
dpipe_Close(source);
}
int
main(int argc, char **argv)
{
int nx,nz,ix,iz,verbose;
float tmp;
float **c11,**c13,**c33,**c44,**vp,**vs,**rho,**eps, **delta;
/* input files */
char *c11_file, *c13_file, *c33_file, *c44_file;
FILE *c11fp, *c13fp, *c33fp, *c44fp;
/* output files */
char *vp_file,*vs_file,*rho_file,*eps_file,*delta_file;
FILE *vpfp,*vsfp,*rhofp,*epsfp,*deltafp;
/* hook up getpar */
initargs(argc, argv);
requestdoc(1);
/* get required parameters */
MUSTGETPARINT("nx", &nx );
MUSTGETPARINT("nz", &nz );
/* get parameters */
if (!getparstring("rho_file", &rho_file)) rho_file="rho.bin";
if (!getparstring("c11_file", &c11_file)) c11_file="c11.bin";
if (!getparstring("c13_file", &c13_file)) c13_file="c13.bin";
if (!getparstring("c33_file", &c33_file)) c33_file="c33.bin";
if (!getparstring("c44_file", &c44_file)) c44_file="c44.bin";
if (!getparstring("vp_file", &vp_file)) vp_file="vp.bin";
if (!getparstring("vs_file", &vs_file)) vs_file="vs.bin";
if (!getparstring("eps_file", &eps_file)) eps_file="eps.bin";
if (!getparstring("delta_file", &delta_file)) delta_file="delta.bin";
if (!getparint("verbose", &verbose)) verbose = 1;
checkpars();
/* allocate space */
rho = alloc2float(nz,nx);
c11 = alloc2float(nz,nx);
c13 = alloc2float(nz,nx);
c33 = alloc2float(nz,nx);
c44 = alloc2float(nz,nx);
vp = alloc2float(nz,nx);
vs = alloc2float(nz,nx);
eps = alloc2float(nz,nx);
delta = alloc2float(nz,nx);
/* read mandatory input files */
rhofp = efopen(rho_file,"r");
if (efread(*rho, sizeof(float), nz*nx, rhofp)!=nz*nx)
err("error reading rho_file=%s!\n",rho_file);
c11fp = efopen(c11_file,"r");
if (efread(*c11, sizeof(float), nz*nx, c11fp)!=nz*nx)
err("error reading c11_file=%s!\n",c11_file);
c13fp = efopen(c13_file,"r");
if (efread(*c13, sizeof(float), nz*nx, c13fp)!=nz*nx)
err("error reading c13_file=%s!\n",c13_file);
c33fp = efopen(c33_file,"r");
if (efread(*c33, sizeof(float), nz*nx, c33fp)!=nz*nx)
err("error reading c33_file=%s!\n",c33_file);
c44fp = efopen(c44_file,"r");
if (efread(*c44, sizeof(float), nz*nx, c44fp)!=nz*nx)
err("error reading c44_file=%s!\n",c44_file);
fclose(rhofp);
fclose(c11fp);
fclose(c13fp);
fclose(c33fp);
fclose(c44fp);
/* open output file: */
vpfp = fopen(vp_file,"w");
vsfp = fopen(vs_file,"w");
epsfp = fopen(eps_file,"w");
deltafp = fopen(delta_file,"w");
/* loop over gridpoints and do calculations */
for(ix=0; ix<nx; ++ix){
for(iz=0; iz<nz; ++iz){
vp[ix][iz] = sqrt(c33[ix][iz]/rho[ix][iz]);
vs[ix][iz] = sqrt(c44[ix][iz]/rho[ix][iz]);
eps[ix][iz] = (c11[ix][iz]-c33[ix][iz])/(2*c33[ix][iz]);
tmp = (c13[ix][iz]+c44[ix][iz])*(c13[ix][iz]+c44[ix][iz]);
tmp = tmp - (c33[ix][iz]-c44[ix][iz])*(c33[ix][iz]-c44[ix][iz]);
delta[ix][iz] = tmp/(2*c33[ix][iz]*(c33[ix][iz]-c44[ix][iz]));
}
}
/* write the output files to disk */
efwrite(*vp,sizeof(float),nz*nx,vpfp);
efwrite(*vs,sizeof(float),nz*nx,vsfp);
efwrite(*eps,sizeof(float),nz*nx,epsfp);
efwrite(*delta,sizeof(float),nz*nx,deltafp);
if(verbose){
warn("Output file for vp : %s ",vp_file);
warn("Output file for vs : %s ",vs_file);
warn("Output file for epsilon : %s ",eps_file);
warn("Output file for delta : %s ",delta_file);
}
/* free workspace */
free2float(vp);
free2float(vs);
free2float(rho);
free2float(eps);
free2float(delta);
free2float(c11);
free2float(c13);
free2float(c33);
free2float(c44);
return(CWP_Exit());
}
int main(int argc, char **argv) /*argc, argv - the arguments to the main() function*/
{
int nt; /*number of time samples*/
int nz; /*number of migrated depth samples*/
int nx; /*number of midpoints (traces)*/
int ix;
int iz;
float dt; /*time sampling interval*/
float dx; /*spatial sampling interval*/
float dz; /*migrated depth sampling interval*/
float **data; /*input seismic data*/
complex **image; /*migrated image*/
float **rimage; /*migrated image*/
float **v; /*velocity model*/
FILE *vfp;
char *vfile=""; /*name of velocity file*/
int verbose=1;
char *tmpdir; /* directory path for tmp files*/
cwp_Bool istmpdir=cwp_false; /* true for user-given path*/
/******************************* Intialize *********************************************/
initargs(argc,argv);
requestdoc(1);
/********************************* Get parameters **************************************/
/*get info from first trace*/
if (!gettr(&tr)) err("can't get first trace"); /*fgettr: get a fixed-length segy trace from a file by file pointer*/
nt = tr.ns; /*nt*/ /*gettr: macro using fgettr to get a trace from stdin*/
if (!getparfloat("dt", &dt)) { /*dt*/
if (tr.dt) {
dt = ((double) tr.dt)/1000000.0;
}
else {err("dt is not set");}
}
if (!getparfloat("dx", &dx)) { /*dx*/
if (tr.d2) {
dx = tr.d2;
}
else {
err("dx is not set");
}
}
/*get optional parameters*/
if (!getparint("nz",&nz)) err("nz must be specified");
if (!getparfloat("dz",&dz)) err("dz must be specified");
if (!getparstring("vfile", &vfile)) err("velocity file must be specified");
if (!getparint("verbose", &verbose)) verbose = 0;
/****************************************************************************************/
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
checkpars();
/**************************** Count trace number nx ******************************/
/* store traces and headers in tempfiles while getting a count */
if (STREQ(tmpdir,"")) {
tracefp = etmpfile();
headerfp = etmpfile();
if (verbose) warn("using tmpfile() call");
}
else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(tracefile, temporary_filename(directory));
strcpy(headerfile, temporary_filename(directory));
/* Trap signals so can remove temp files */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
tracefp = efopen(tracefile, "w+");
headerfp = efopen(headerfile, "w+");
istmpdir=cwp_true;
if (verbose) warn("putting temporary files in %s", directory);
}
nx = 0;
do {
++nx; /*get the number of traces nx*/
efwrite(&tr,HDRBYTES,1,headerfp);
efwrite(tr.data, FSIZE, nt, tracefp);
} while (gettr(&tr));
erewind(tracefp); /*Set position of stream to the beginning*/
erewind(headerfp);
/******************************************************************************************/
/*allocate memory*/
data = alloc2float(nt,nx); /*2D array nx by nt*/
image = alloc2complex(nz,nx); /*2D array nx by nz*/
rimage = alloc2float(nz,nx); /*2D array nx by nz*/
v= alloc2float(nz,nx); /*2D array, in Fortran the velocity model is nz by nx 2D array*/
/*in binary, it is actually 1D*/
/* load traces into the zero-offset array and close tmpfile */
efread(*data, FSIZE, nt*nx, tracefp); /*read traces to data*/
efclose(tracefp);
/*load velicoty file*/
vfp=efopen(vfile,"r");
efread(v[0],FSIZE,nz*nx,vfp); /*load velocity*/
efclose(vfp);
/***********************finish reading data*************************************************/
/* call pspi migration function*/
pspimig(data,image,v,nt,nx,nz,dt,dx,dz);
/*get real part of image*/
for (iz=0;iz<nz;iz++){
for (ix=0;ix<nx;ix++){
rimage[ix][iz] = image[ix][iz].r;
}
}
/* restore header fields and write output */
for (ix=0; ix<nx; ix++) {
efread(&tr,HDRBYTES,1,headerfp);
tr.ns = nz;
tr.d1 = dz;
memcpy( (void *) tr.data, (const void *) rimage[ix],nz*FSIZE);
puttr(&tr);
}
/* Clean up */
efclose(headerfp);
if (istmpdir) eremove(headerfile);
if (istmpdir) eremove(tracefile);
return(CWP_Exit());
}
int main(int argc, char **argv)
{
char *plotcmd; /* build pswigb command for popen */
float *trbuf; /* trace buffer */
FILE *plotfp; /* fp for plot data */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
int verbose; /* verbose flag */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
cwp_Bool seismic; /* is this seismic data? */
cwp_Bool have_ntr=cwp_false;/* is ntr known from header or user? */
char *tmpdir; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false;/* true for user given path */
char *cwproot; /* value of CWPROOT environment variable*/
char *bindir; /* directory path for tmp files */
/* Support for irregularly spaced data */
cwp_String key; /* header key word with x2 information */
cwp_String type1=NULL; /* ... its type */
int index1=0; /* ... its index */
Value val; /* value of key */
Value scale; /* Value of scaler */
cwp_String type2=NULL; /* ... its type */
int index2=0; /* ... its index */
cwp_Bool isDepth=cwp_false; /* Is this key a type of depth? */
cwp_Bool isCoord=cwp_false; /* Is this key a type of coordinate? */
cwp_Bool irregular=cwp_false; /* if true, reading x2 from header */
cwp_String x2string; /* string of x2 values */
off_t x2len; /* ... its length */
cwp_String style; /* style parameter */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get info from first trace */
if (!gettr(&tr)) err("can't get first trace");
seismic = ISSEISMIC(tr.trid);
nt = tr.ns;
ntr = tr.ntr;
if (ntr) have_ntr = cwp_true;
if (!getparint("verbose", &verbose)) verbose=0;
if (!getparfloat("d1", &d1)) {
if (tr.d1) d1 = tr.d1;
else if (tr.dt) d1 = ((double) tr.dt)/1000000.0;
else {
if (seismic) {
d1 = 0.004;
warn("tr.dt not set, assuming dt=0.004");
} else { /* non-seismic data */
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("f1", &f1)) {
if (tr.f1) f1 = tr.f1;
else if (tr.delrt) f1 = (float) tr.delrt/1000.0;
else f1 = 0.0;
}
/* Get or set ntr */
if (getparint("n2", &ntr) || getparint("ntr", &ntr)) have_ntr = cwp_true;
if (!getparfloat("d2", &d2)) d2 = (tr.d2) ? tr.d2 : 1.0;
if (!getparfloat("f2", &f2)) {
if (tr.f2) f2 = tr.f2;
else if (tr.tracr) f2 = (float) tr.tracr;
else if (tr.tracl) f2 = (float) tr.tracl;
else if (seismic) f2 = 1.0;
else f2 = 0.0;
}
if (!getparstring("style", &style)) style = "seismic";
if (getparstring("key", &key)) {
type1 = hdtype(key);
if ( (index1 = getindex(key)) == -1 )
err("%s: keyword not in segy.h: '%s'", __FILE__, key);
irregular = cwp_true;
isDepth = IS_DEPTH(key);
isCoord = IS_COORD(key);
if (isDepth) {
index2 = getindex("scalel");
type2 = hdtype("scalel");
} else if (isCoord) {
index2 = getindex("scalco");
type2 = hdtype("scalco");
}
}
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* See if CWPBIN environment variable is not set */
if (!(bindir = getenv("CWPBIN"))) { /* construct bindir from CWPROOT */
bindir = (char *) emalloc(BUFSIZ);
/* Get value of CWPROOT environment variable */
if (!(cwproot = getenv("CWPROOT"))) cwproot ="" ;
if (STREQ(cwproot, "")) {
warn("CWPROOT environment variable is not set! ");
err("Set CWPROOT in shell environment as per instructions in CWP/SU Installation README files");
}
/* then bindir = $CWPROOT/bin */
sprintf(bindir, "%s/bin", cwproot);
}
strcat(bindir,"/"); /* put / at the end of bindir */
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
if (!have_ntr || irregular ) { /* count traces */
if (verbose) {
if (irregular) {
warn("trace spacing from header field %s",key);
warn("... getting positions");
} else {
warn("n2 not getparred and "
"ntr header field not set");
warn(".... counting traces");
}
}
/* Create temporary "file" to hold data */
if (STREQ(tmpdir,"")) {
datafp = etmpfile();
if (irregular) x2fp = etmpfile();
if (verbose) warn("using tmpfile() call");
} else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(datafile, temporary_filename(directory));
strcpy(x2file, temporary_filename(directory));
/* Handle user interrupts */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
datafp = efopen(datafile, "w+");
if (irregular) x2fp = efopen(x2file, "w+");
istmpdir=cwp_true;
if (verbose)
warn("putting temporary files in %s", directory);
}
/* Loop over input data and read to temporary file */
ntr = 0;
if(irregular ) {
float x,xmin=FLT_MAX,xmax=-FLT_MAX;
fprintf(x2fp,"x2=");
do {
if(ntr) fprintf(x2fp,",");
++ntr;
gethval(&tr,index1,&val);
if (isDepth || isCoord) {
gethval(&tr,index2,&scale);
x = (float) (vtod(type1,val) *
pow(10.0,vtod(type2,scale)));
} else
x = vtof(type1,val);
fprintf(x2fp,"%g",x);
xmin = MIN(xmin,x);
xmax = MAX(xmax,x);
if (isDepth && STREQ(style,"vsp")) {
int i;
for (i = 0; i < nt; ++i) tr.data[i] *= -1.0;
}
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* Flip vertical axis if style = vsp */
if (isDepth && STREQ(style,"vsp")) {
fprintf(x2fp," x2beg=%g x2end=%g",xmax,xmin);
style = "normal";
}
if(xmin==xmax) {
warn("values in header %s all equal,",key);
warn("using f2=%f d2=%f",f2,d2);
irregular=cwp_false;
have_ntr=cwp_false;
efclose(x2fp);
if (istmpdir) eremove(x2file);
}
} else {
do {
++ntr;
efwrite(tr.data, FSIZE, nt, datafp);
} while (gettr(&tr));
/* Save naive user */
if (STREQ(style,"vsp")) {
style = "normal";
warn("style=vsp requires key= to be set");
}
}
}
/* Set up pswigb command line */
if (irregular ) {
x2len = (off_t) eftell( x2fp );
x2string = (char *) emalloc( ++x2len );
rewind(x2fp);
fread(x2string,sizeof(char),x2len,x2fp);
plotcmd = (char *) emalloc(x2len+BUFSIZ);
if (STREQ(style,"vsp")) {
style = "normal";
}
sprintf(plotcmd, "%spswigb n1=%d d1=%f f1=%f %s style=%s", bindir,
nt, d1, f1, x2string, style);
free(x2string);
} else {
if (STREQ(style,"vsp")) {
style = "normal";
}
plotcmd = (char *) emalloc(BUFSIZ);
sprintf(plotcmd,
"%spswigb n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f style=%s", bindir,
nt, ntr, d1, d2, f1, f2, style);
}
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "d1=", 3) && /* skip those already set */
strncmp(*argv, "d2=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "f2=", 3) &&
strncmp(*argv, "style=", 6)){
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe to pswigb and send the traces */
plotfp = epopen(plotcmd, "w");
free(plotcmd);
if (!have_ntr || irregular) { /* send out stored traces one by one */
rewind(datafp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, datafp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
} else { /* just pump out traces and let pswigb do the work */
do {
efwrite(tr.data, FSIZE, nt, plotfp);
} while (gettr(&tr));
}
/* Clean up */
epclose(plotfp);
if (!have_ntr) {
efclose(datafp);
if (istmpdir) eremove(datafile);
}
if (irregular) {
efclose(x2fp);
if (istmpdir) eremove(x2file);
}
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
char *key=NULL; /* header key word from segy.h */
char *type=NULL; /* ... its type */
int index; /* ... its index */
Value val; /* ... its value */
float fval; /* ... its value cast to float */
float *xshift=NULL; /* array of key shift curve values */
float *tshift=NULL; /* ... shift curve time values */
int nxshift; /* number of key shift values */
int ntshift; /* ... shift time values */
int nxtshift; /* number of shift values */
int it; /* sample counter */
int itr; /* trace counter */
int nt; /* number of time samples */
int ntr=0; /* number of traces */
int *inshift=NULL; /* array of (integer) time shift values
used for positioning shifted trace in
data[][] */
float dt; /* time sampling interval */
cwp_String xfile=""; /* file containing positions by key */
FILE *xfilep=NULL; /* ... its file pointer */
cwp_String tfile=""; /* file containing times */
FILE *tfilep=NULL; /* ... its file pointer */
int verbose; /* flag for printing information */
char *tmpdir=NULL; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false;/* true for user-given path */
int median; /* flag for median filter */
int nmed; /* no. of traces to median filter */
int nmix; /* number of traces to mix over */
int imix; /* mixing counter */
float *mix=NULL; /* array of mix values */
int sign; /* flag for up/down shift */
int shiftmin=0; /* minimum time shift (in samples) */
int shiftmax=0; /* maximum time shift (in samples) */
int ntdshift; /* nt + shiftmax */
size_t mixbytes; /* size of mixing array */
size_t databytes; /* size of data array */
size_t shiftbytes; /* size of data array */
float *temp=NULL; /* temporary array */
float *dtemp=NULL; /* temporary array */
float *stemp=NULL; /* rwh median sort array */
float **data=NULL; /* mixing array */
int subtract; /* flag for subtracting shifted data */
/* rwh extra pointers for median sort */
int first; /* start pointer in ring buffer */
int middle; /* middle pointer in ring buffer */
int last; /* last pointer in ring buffer */
int halfwidth; /* mid point */
int trcount; /* pointer to current start trace number */
float tmp; /* temp storage for bubble sort */
int rindex; /* wrap around index for ring buffer */
int jmix; /* internal pointer for bubble sort */
/* Initialize */
initargs(argc, argv);
requestdoc(1);
/* Get parameters */
if (!(getparstring("xfile",&xfile) && getparstring("tfile",&tfile))) {
if (!(nxshift = countparval("xshift")))
err("must give xshift= vector");
if (!(ntshift = countparval("tshift")))
err("must give tshift= vector");
if (nxshift != ntshift)
err("lengths of xshift, tshift must be the same");
xshift = ealloc1float(nxshift); getparfloat("xshift", xshift);
tshift = ealloc1float(nxshift); getparfloat("tshift", tshift);
} else {
MUSTGETPARINT("nshift",&nxtshift);
nxshift = nxtshift;
xshift = ealloc1float(nxtshift);
tshift = ealloc1float(nxtshift);
if((xfilep=fopen(xfile,"r"))==NULL)
err("cannot open xfile=%s\n",xfile);
if (fread(xshift,sizeof(float),nxtshift,xfilep)!=nxtshift)
err("error reading xfile=%s\n",xfile);
fclose(xfilep);
if((tfilep=fopen(tfile,"r"))==NULL)
err("cannot open tfile=%s\n",tfile);
if (fread(tshift,sizeof(float),nxtshift,tfilep)!=nxtshift)
err("error reading tfile=%s\n",tfile);
fclose(tfilep);
}
if (!getparstring("key", &key)) key = "tracl";
/* Get key type and index */
type = hdtype(key);
index = getindex(key);
/* Get mix weighting values values */
if ((nmix = countparval("mix"))!=0) {
mix = ealloc1float(nmix);
getparfloat("mix",mix);
/* rwh check nmix is odd */
if (nmix%2==0) {
err("number of mixing coefficients must be odd");
}
} else {
nmix = 5;
mix = ealloc1float(nmix);
mix[0] = VAL0;
mix[1] = VAL1;
mix[2] = VAL2;
mix[3] = VAL3;
mix[4] = VAL4;
}
/* Get remaning parameters */
if (!getparint("median",&median)) median = 0;
if (!getparint("nmed",&nmed) && median) nmed = 5;
if (!getparint("sign",&sign)) sign = -1;
if (!getparint("subtract",&subtract)) subtract = 1;
if (!getparint("verbose", &verbose)) verbose = 0;
/* rwh check nmed is odd */
if (median && nmed%2==0) {
nmed=nmed+1;
warn("increased nmed by 1 to ensure it is odd");
}
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* rwh fix for median filter if median true set nmix=nmed */
if (!median) {
/* Divide mixing weights by number of traces to mix */
for (imix = 0; imix < nmix; ++imix)
mix[imix]=mix[imix]/((float) nmix);
} else {
nmix=nmed;
}
/* Get info from first trace */
if (!gettr(&tr)) err("can't read first trace");
if (!tr.dt) err("dt header field must be set");
dt = ((double) tr.dt)/1000000.0;
nt = (int) tr.ns;
databytes = FSIZE*nt;
/* Tempfiles */
if (STREQ(tmpdir,"")) {
tracefp = etmpfile();
headerfp = etmpfile();
if (verbose) warn("using tmpfile() call");
} else { /* user-supplied tmpdir */
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(tracefile, temporary_filename(directory));
strcpy(headerfile, temporary_filename(directory));
/* Trap signals so can remove temp files */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
tracefp = efopen(tracefile, "w+");
headerfp = efopen(headerfile, "w+");
istmpdir=cwp_true;
if (verbose) warn("putting temporary files in %s", directory);
}
/* Read headers and data while getting a count */
do {
++ntr;
efwrite(&tr, 1, HDRBYTES, headerfp);
efwrite(tr.data, 1, databytes, tracefp);
} while (gettr(&tr));
rewind(headerfp);
rewind(tracefp);
/* Allocate space for inshift vector */
inshift = ealloc1int(ntr);
/* Loop over headers */
for (itr=0; itr<ntr; ++itr) {
float tmin=tr.delrt/1000.0;
float t;
/* Read header values */
efread(&tr, 1, HDRBYTES, headerfp);
/* Get value of key and convert to float */
gethval(&tr, index, &val);
fval = vtof(type,val);
/* Linearly interpolate between (xshift,tshift) values */
intlin(nxshift,xshift,tshift,tmin,tshift[nxshift-1],1,&fval,&t);
/* allow for fractional shifts -> requires interpolation */
inshift[itr] = NINT((t - tmin)/dt);
/* Find minimum and maximum shifts */
if (itr==0) {
shiftmax=inshift[0];
shiftmin=inshift[0];
} else {
shiftmax = MAX(inshift[itr],shiftmax);
shiftmin = MIN(inshift[itr],shiftmin);
}
}
rewind(headerfp);
rewind(tracefp);
if (verbose) {
for (itr=0;itr<ntr;itr++)
warn("inshift[%d]=%d",itr,inshift[itr]);
}
/* Compute databytes per trace and bytes in mixing panel */
ntdshift = nt + shiftmax;
shiftbytes = FSIZE*ntdshift;
mixbytes = shiftbytes*nmix;
if (verbose) {
warn("nt=%d shiftmax=%d shiftmin=%d",nt,shiftmax,shiftmin);
warn("ntdshift=%d shiftbytes=%d mixbytes=%d",
ntdshift,shiftbytes,mixbytes);
}
/* Allocate space and zero data array */
data = ealloc2float(ntdshift,nmix);
temp = ealloc1float(ntdshift);
dtemp = ealloc1float(nt);
memset( (void *) data[0], 0, mixbytes);
/* rwh array for out of place bubble sort (so we do not corrupt order in ring buffer */
stemp = ealloc1float(nmix);
/* rwh first preload ring buffer symmetrically (now you know why nmix must be odd) */
trcount=-1;
halfwidth=(nmix-1)/2+1;
first = 0;
last = nmix-1;
middle = (nmix-1)/2;
for (itr=0; itr<halfwidth; itr++) {
efread(tr.data, 1, databytes, tracefp);
trcount++;
for(it=0; it<nt; ++it) {
/* sign to account for positive or negative shift */
/* tr.data needs to be interpolated for non-integer shifts */
data[middle-itr][it + shiftmax + sign*inshift[itr]] = tr.data[it];
data[middle+itr][it + shiftmax + sign*inshift[itr]] = tr.data[it];
}
}
/* Loop over traces performing median filtering */
for (itr=0; itr<ntr; ++itr) {
/* paste header and data on output trace */
efread(&tr, 1, HDRBYTES, headerfp);
/* Zero out temp and dtemp */
memset((void *) temp, 0, shiftbytes);
memset((void *) dtemp, 0, databytes);
/* Loop over time samples */
for (it=0; it<nt; ++it) {
/* Weighted moving average (mix) ? */
if (!median) {
for(imix=0; imix<nmix; ++imix) {
temp[it] += data[imix][it] * mix[imix];
}
} else {
/* inlcude median stack */
/* rwh do bubble sort and choose median value */
for(imix=0; imix<nmix; ++imix) {
stemp[imix]=data[imix][it];
}
for (imix=0; imix<nmix-1; imix++) {
for (jmix=0; jmix<nmix-1-imix; jmix++) {
if (stemp[jmix+1] < stemp[jmix]) {
tmp = stemp[jmix];
stemp[jmix] = stemp[jmix+1];
stemp[jmix+1] = tmp;
}
}
}
temp[it] = stemp[middle];
}
/* shift back mixed data and put into dtemp */
if (subtract) {
if ((it - shiftmax - sign*inshift[itr])>=0)
dtemp[it - shiftmax - sign*inshift[itr]] = data[middle][it]-temp[it];
} else {
if ((it - shiftmax)>=0)
dtemp[it - shiftmax - sign*inshift[itr]] = temp[it];
}
}
memcpy((void *) tr.data,(const void *) dtemp,databytes);
/* Bump rows of data[][] over by 1 to free first row for next tr.data */
for (imix=nmix-1; 0<imix; --imix)
memcpy((void *) data[imix],(const void *) data[imix-1],shiftbytes);
/*for (it=0; it<nt; ++it)
data[imix][it] = data[imix-1][it];*/
/* Write output trace */
tr.ns = nt;
puttr(&tr);
/* read next trace into buffer */
if (trcount < ntr) {
efread(tr.data, 1, databytes, tracefp);
trcount++;
/* read tr.data into first row of mixing array */
/* WMH: changed ntdshift to nt */
for(it=0; it<nt; ++it) {
/* sign to account for positive or negative shift */
/* tr.data needs to be interpolated for non-integer shifts */
data[0][it + shiftmax + sign*inshift[trcount]] = tr.data[it];
}
} else {
rindex=2*(trcount-ntr);
memcpy((void *) data[0],(const void *) data[rindex],shiftbytes);
trcount++;
}
}
if (verbose && subtract) warn("filtered data subtracted from input");
/* Clean up */
efclose(headerfp);
if (istmpdir) eremove(headerfile);
efclose(tracefp);
if (istmpdir) eremove(tracefile);
return(CWP_Exit());
}
int
main(int argc, char **argv)
{
char *tmpdir ; /* directory path for tmp files */
cwp_Bool istmpdir=cwp_false ; /* true for user given path */
float *hedr ; /* the headers */
float *data ; /* the data */
int nt ; /* number of trace samples */
float dt ; /* sample interval, sec */
float delrt ; /* delay recording time, sec */
cwp_String key[SU_NKEYS] ; /* array of keywords */
cwp_String type ; /* key string type */
int nkeys ; /* number of keywords */
int ikey,ntr = 0 ; /* counters */
int num ; /* number of traces to dump */
int numtr = 4 ; /* number of traces to dump */
int hpf ; /* header print format */
/* Initialize */
initargs(argc, argv) ;
requestdoc(1) ;
/* Look for user-supplied tmpdir */
if (!getparstring("tmpdir",&tmpdir) &&
!(tmpdir = getenv("CWP_TMPDIR"))) tmpdir="";
if (!STREQ(tmpdir, "") && access(tmpdir, WRITE_OK))
err("you can't write in %s (or it doesn't exist)", tmpdir);
/* Get values from first trace */
if (!gettr(&tr)) err("can't get first trace");
nt = (int) tr.ns ; /* Get nt */
dt = ((double) tr.dt)/1000000.0 ; /* microsecs to secs */
if (!dt) getparfloat("dt", &dt) ;
if (!dt) MUSTGETPARFLOAT("dt", &dt) ;
delrt = ((double) tr.delrt)/1000.0 ; /* millisecs to secs */
/* Get parameters */
if (getparint ("num", &num)) numtr = num ;
if ((nkeys=countparval("key"))!=0) getparstringarray("key",key) ;
hedr = ealloc1float(nkeys*numtr) ; /* make space for headers */
if (!getparint ("hpf", &hpf)) hpf = 0 ;
/* Store traces, headers in tempfiles */
if (STREQ(tmpdir,""))
{
tracefp = etmpfile();
headerfp = etmpfile();
do
{
++ntr;
efwrite(&tr, HDRBYTES, 1, headerfp);
efwrite(tr.data, FSIZE, nt, tracefp);
/* Get header values */
for (ikey=0; ikey<nkeys; ++ikey)
{
Value val;
float fval;
gethdval(&tr, key[ikey], &val) ;
type = hdtype(key[ikey]) ;
fval = vtof(type,val) ;
hedr[(ntr-1)*nkeys+ikey] = fval ;
}
}
while (ntr<numtr && gettr(&tr)) ;
}
else /* user-supplied tmpdir */
{
char directory[BUFSIZ];
strcpy(directory, tmpdir);
strcpy(tracefile, temporary_filename(directory));
strcpy(headerfile, temporary_filename(directory));
/* Handle user interrupts */
signal(SIGINT, (void (*) (int)) closefiles);
signal(SIGQUIT, (void (*) (int)) closefiles);
signal(SIGHUP, (void (*) (int)) closefiles);
signal(SIGTERM, (void (*) (int)) closefiles);
tracefp = efopen(tracefile, "w+");
headerfp = efopen(headerfile, "w+");
istmpdir=cwp_true;
do
{
++ntr;
efwrite(&tr, HDRBYTES, 1, headerfp);
efwrite(tr.data, FSIZE, nt, tracefp);
/* Get header values */
for (ikey=0; ikey<nkeys; ++ikey)
{
Value val;
float fval;
gethdval(&tr, key[ikey], &val) ;
type = hdtype(key[ikey]) ;
fval = vtof(type,val) ;
hedr[(ntr-1)*nkeys+ikey] = fval ;
}
}
while (ntr<numtr && gettr(&tr)) ;
}
/* Rewind after read, allocate space */
erewind(tracefp);
erewind(headerfp);
data = ealloc1float(nt*ntr);
/* Load traces into data and close tmpfile */
efread(data, FSIZE, nt*ntr, tracefp);
efclose(tracefp);
if (istmpdir) eremove(tracefile);
rewind(headerfp);
rewind(tracefp);
/* Do trace work */
dump(data, dt, hedr, key, delrt, nkeys, ntr, nt, hpf) ;
/* close */
efclose(headerfp);
if (istmpdir) eremove(headerfile);
free1(hedr) ;
free1(data) ;
return(CWP_Exit()) ;
}
main(int argc, char **argv)
{
FILE *fpr, *fpw;
char msg[BUFSIZ];
char erbuf[BUFSIZ], ewbuf[BUFSIZ], rbuf[BUFSIZ], wbuf[BUFSIZ];
char pbuf[1], pfbuf[1];
size_t mbytes, rbytes, wbytes;
size_t ritems, witems;
initargs(argc, argv);
/* Exercise efread and efwrite */
fpw = efopen("junk.fwr", "w+");
strcpy(ewbuf, " Writing with efwrite\n");
witems = strlen(ewbuf);
efwrite(ewbuf, 1, witems, fpw);
erewind(fpw);
fread(rbuf, 1, witems, fpw);
erewind(fpw);
strcpy(msg, "***efwrite from file to buffer ...");
mbytes = strlen(msg);
fwrite(msg, 1, mbytes, stdout);
fwrite(rbuf, 1, witems, stdout);
fpr = fopen("junk.frd", "w+");
strcpy(wbuf, " Reading with efread\n");
ritems = strlen(wbuf);
fwrite(wbuf, 1, ritems, fpr);
erewind(fpr);
strcpy(wbuf, " efread saw zero bytes\n");
witems = strlen(wbuf);
strcpy(msg, "***efread from file to buffer ...");
mbytes = strlen(msg);
fwrite(msg, 1, mbytes, stdout);
if (!efread(erbuf, 1, ritems, fpr)) {
fwrite(wbuf, 1, witems, stdout);
} else {
fwrite(erbuf, 1, ritems, stdout);
}
erewind(fpr);
strcpy(wbuf, " Reading byte by byte with efread\n");
ritems = strlen(wbuf);
fwrite(wbuf, 1, ritems, fpr);
erewind(fpr);
strcpy(wbuf, " exit loop: efread returned zero\n");
witems = strlen(wbuf);
strcpy(msg, "***efread file byte by byte to buffer ...");
mbytes = strlen(msg);
fwrite(msg, 1, mbytes, stdout);
while (efread(erbuf, 1, 1, fpr)) {
fwrite(erbuf, 1, 1, stdout);
}
erewind(fpr);
fwrite(wbuf, 1, witems, stdout);
strcpy(wbuf, "");
ritems = strlen(wbuf);
fwrite(wbuf, 1, ritems, fpr);
erewind(fpr);
strcpy(wbuf, " efread saw zero bytes\n");
witems = strlen(wbuf);
strcpy(msg, "***efread from EMPTY file to buffer ...");
mbytes = strlen(msg);
fwrite(msg, 1, mbytes, stdout);
efread(erbuf, 1, ritems, fpr);
erewind(fpr);
fwrite(wbuf, 1, witems, stdout);
efclose(fpw);
efclose(fpr);
eremove("junk.frd");
eremove("junk.fwr");
return EXIT_SUCCESS;
}
main(int argc, char **argv)
{
FILE *infp=stdin, *outfp=stdout;
usghed usgh;
int ierr;
float *grid, *g, *g1;
int i1, i2, i3;
int k1, k2, k3;
int h1, h2, h3;
int n1, n2, n3;
int j1, j2, j3;
int m1, m2, m3;
int i;
float gmin, gmax;
float tmp;
int op, w1, w2, w3;
int nz, iz;
int si1, si2, si3, ni1, ni2, ni3;
/* initialization */
initargs(argc,argv);
askdoc(1);
/* large than 2 GB files */
file2g(infp);
file2g(infp);
/* read in the grid header */
ierr = fgetusghdr(infp, &usgh);
if(ierr!=0) err("non standard grid header input ");
/* get the dimensions of input grid */
n1 = usgh.n1;
n2 = usgh.n2;
n3 = usgh.n3;
/* get input parameters */
if (!getparint("op",&op)) op = 0;
if (!getparint("w1",&w1)) w1 = 5;
if (!getparint("w2",&w2)) w2 = 5;
if (!getparint("w3",&w3)) w3 = 5;
if(w1<1) w1 = 1; if(w1>n1) w1 = n1;
if(w2<1) w2 = 1; if(w2>n2) w2 = n2;
if(w3<1) w3 = 1; if(w3>n3) w3 = n3;
if (!getparint("si1",&si1)) si1 = 1; if(si1<1)si1=1; if(si1>n1)si1=n1;
if (!getparint("si2",&si2)) si2 = 1; if(si2<1)si2=1; if(si2>n2)si2=n2;
if (!getparint("si3",&si3)) si3 = 1; if(si3<1)si3=1; if(si3>n3)si3=n3;
if (!getparint("ni1",&ni1)) ni1 = n1; if(ni1<1)ni1=1;if(ni1>n1)ni1=n1;
if (!getparint("ni2",&ni2)) ni2 = n2; if(ni2<1)ni2=1;if(ni2>n2)ni2=n2;
if (!getparint("ni3",&ni3)) ni3 = n3; if(ni3<1)ni3=1;if(ni3>n3)ni3=n3;
/* memory allocations */
if(n1*n2*n3>1024*1024*1024/4)
err(" input grid too big; subsample recommended \n");
grid = (float*)emalloc(n1*n2*n3*sizeof(float));
g = (float*)emalloc(w1*w2*w3*sizeof(float));
g1 = (float*) emalloc(n1*sizeof(float));
fseek64(infp,0,0);
efread(grid,sizeof(float),n1*n2*n3,infp);
h1 = w1/2;
h2 = w2/2;
h3 = w3/2;
nz = w1*w2*w3;
iz = (50*nz/100.);
si1 = si1 - 1;
si2 = si2 - 1;
si3 = si3 - 1;
for (i3=0;i3<n3;i3++) {
for (i2=0;i2<n2;i2++) {
k3 = i3 - h3;
k2 = i2 - h2;
for(i1=0;i1<n1;i1++) g1[i1] = grid[i1+i2*n1+i3*n1*n2];
if( i2>=si2 && i2<ni2 && i3>=si3 && i3<ni3 ) {
for (i1=si1-1;i1<ni1;i1++) {
i = 0;
k1 = i1 - h1;
for (j3=k3;j3<k3+w3;j3++) {
m3=j3;
if(m3<0)m3=0;
if(m3>n3-1)m3=n3-1;
for (j2=k2;j2<k2+w2;j2++) {
m2=j2;
if(m2<0)m2=0;
if(m2>n2-1)m2=n2-1;
for (j1=k1;j1<k1+w1;j1++) {
m1=j1;
if(m1<0)m1=0;
if(m1>n1-1)m1=n1-1;
g[i] = grid[m1+m2*n1+m3*n1*n2];
i = i + 1;
}
}
}
if(op==0) {
qkfind(iz,nz,g);
g1[i1] = g[iz];
} else if(op==1) {
tmp = 0.;
for(i=0;i<nz;i++) {
tmp = tmp + g[i];
}
g1[i1] = tmp/nz;
}
}
}
if(i2==0 && i3==0) {
gmin = g1[0];
gmax = g1[0];
}
for(i1=0;i1<n1;i1++) {
if(gmin>g1[i1]) gmin = g1[i1];
if(gmax<g1[i1]) gmax = g1[i1];
}
fwrite(g1,sizeof(float),n1,outfp);
}
}
/* update the output gridheader header */
usgh.gmin = gmin;
usgh.gmax = gmax;
/* output the grid header */
ierr = fputusghdr(outfp, &usgh);
if(ierr!=0) err("output grid header error ");
free(grid);
free(g);
free(g1);
exit(0);
}
main(int argc, char **argv)
{
char plotcmd[BUFSIZ]; /* build ximage command for popen */
float *trbuf; /* trace buffer */
FILE *datafp; /* fp for trace data file */
FILE *plotfp; /* fp for plot data */
int nt; /* number of samples on trace */
int ntr; /* number of traces */
float d1; /* time/depth sample rate */
float d2; /* trace/dx sample rate */
float f1; /* tmin/zmin */
float f2; /* tracemin/xmin */
bool seismic; /* is this seismic data? */
int panel; /* panel to pick */
int dtype; /* type of display */
int ppos; /* position of the panel */
FILE *infp=stdin;
int n3,n2,n1;
/* Initialize */
initargs(argc, argv);
askdoc(1);
/* Get info from headers and first trace */
fgethdr(infp,&ch,&bh);
n1 = bh.hns;
if(!getparint("ntpp",&n2)) {
if (bh.tsort==2) {
n2 = bh.fold;
} else {
n2 = bh.ntrpr;
}
}
if (!fgettr(infp,&tr)) err("can't get first trace");
nt = tr.ns;
if ( n1!=nt )
warn("samples/trace in bhdr and trhdr different; trhdr used! \n");
n1 = nt;
fseek(infp,0L,2);
n3=(ftell(infp)-EBCBYTES-BNYBYTES)/(n1*sizeof(float)+HDRBYTES)/n2;
if(n3==0) {
n3=1;
n2=(ftell(infp)-EBCBYTES-BNYBYTES)/(n1*sizeof(float)+HDRBYTES);
warn("less traces were found in input! \n");
}
fseek(infp,0L,0);
seismic = (tr.trid == 0 || tr.trid == TREAL);
if (!getparint("panel", &panel)) panel=1;
if (!getparint("dtype", &dtype)) dtype=0;
if (!getparfloat("d1", &d1)) {
if (seismic) {
/* sampling interval in ms or in m (ft) */
if ( tr.dz!=0. ) {
d1 = tr.dz;
} else if (tr.dt) {
d1 = (float) tr.dt / 1000.0;
if (tr.dt<1000) d1 = tr.dt;
} else {
d1 = 0.004 * 1000.;
warn("tr.dt not set, assuming dt=4");
}
} else { /* non-seismic data */
if (tr.d1) {
d1 = tr.d1;
} else {
d1 = 1.0;
warn("tr.d1 not set, assuming d1=1.0");
}
}
}
if (!getparfloat("d2", &d2)) {
if(bh.tsort==2) {
d2 = tr.offset;
}
else {
d2 = tr.cdp;
}
}
if (!getparfloat("f1", &f1)) {
if (seismic) {
f1 = (tr.delrt) ? (float) tr.delrt/1000.0 : 0.0;
if(tr.delrt<1000) f1=tr.delrt;
if(tr.dz!=0.) f1=tr.fz;
} else {
f1 = (tr.f1) ? tr.f1 : 0.0;
}
}
if (!getparfloat("f2", &f2)) {
if (bh.tsort==2) {
f2 = tr.offset;
}
else {
f2 = tr.cdp;
}
}
/* Allocate trace buffer */
trbuf = ealloc1float(nt);
/* Create temporary "file" to hold data */
datafp = etempfile(NULL);
/* Loop over input traces & put them into the data file */
ntr = 0;
fseek(infp,EBCBYTES+BNYBYTES+(panel-1)*n2*(n1*sizeof(float)+HDRBYTES),0);
for(ntr=0;ntr<n2;ntr++) {
if(!fgettr(infp,&tr)) err("get trace error \n");
efwrite(tr.data, FSIZE, nt, datafp);
if(ntr==1) {
if (bh.tsort==2) {
if(!getparfloat("d2",&d2)) d2 = tr.offset-d2;
if (!getparint("ppos", &ppos)) ppos = tr.cdp;
} else {
if(!getparfloat("d2",&d2)) d2 = tr.cdp-d2;
if (!getparint("ppos", &ppos)) ppos = tr.offset;
}
}
}
/* Set up xipick or xwpick command line */
if ( dtype == 0 ) {
sprintf(plotcmd,
"mipick n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f ppos=%d",
n1, n2, d1, d2, f1, f2, ppos);
} else {
sprintf(plotcmd,
"mwpick n1=%d n2=%d d1=%f d2=%f f1=%f f2=%f ppos=%d",
n1, n2, d1, d2, f1, f2, ppos);
}
for (--argc, ++argv; argc; --argc, ++argv) {
if (strncmp(*argv, "d1=", 3) && /* skip those already set */
strncmp(*argv, "d2=", 3) &&
strncmp(*argv, "f1=", 3) &&
strncmp(*argv, "f2=", 3)) {
strcat(plotcmd, " "); /* put a space between args */
strcat(plotcmd, "\""); /* user quotes are stripped */
strcat(plotcmd, *argv); /* add the arg */
strcat(plotcmd, "\""); /* user quotes are stripped */
}
}
/* Open pipe; read data to buf; write buf to plot program */
plotfp = epopen(plotcmd, "w");
rewind(datafp);
{ register int itr;
for (itr = 0; itr < ntr; ++itr) {
efread (trbuf, FSIZE, nt, datafp);
efwrite(trbuf, FSIZE, nt, plotfp);
}
}
/* Clean up */
epclose(plotfp);
efclose(datafp);
return EXIT_SUCCESS;
}