#include<stdio.h>
typedef struct {        /* segy - trace identification header */
        int tracl;      /* trace sequence number within line */
        int tracr;      /* trace sequence number within reel */
        int fldr;       /* field record number */
        int tracf;      /* trace number within field record */
        int ep;         /* energy source point number */
        int cdp;        /* CDP ensemble number */
        int cdpt;       /* trace number within CDP ensemble */
        short trid;     /* trace identification code:
                        1 = seismic data
                        2 = dead
                        3 = dummy
                        4 = time break
                        5 = uphole
                        6 = sweep
                        7 = timing
                        8 = water break
                        9---, N = optional use (N = 32,767)
                        Following are CWP id flags:
                         9 = autocorrelation
                        10 = Fourier transformed - no packing
                             xr[0],xi[0], ..., xr[N-1],xi[N-1]
                        11 = Fourier transformed - unpacked Nyquist
                             xr[0],xi[0],...,xr[N/2],xi[N/2]
                        12 = Fourier transformed - packed Nyquist
                             even N:
                             xr[0],xr[N/2],xr[1],xi[1], ...,
                                xr[N/2 -1],xi[N/2 -1]
                                (note the exceptional second entry)
                             odd N:
                             xr[0],xr[(N-1)/2],xr[1],xi[1], ...,
                                xr[(N-1)/2 -1],xi[(N-1)/2 -1],xi[(N-1)/2]
                                (note the exceptional second & last entries)
                        13 = Complex signal in the time domain
                             xr[0],xi[0], ..., xr[N-1],xi[N-1]
                        14 = Fourier transformed - amplitude/phase
                             a[0],p[0], ..., a[N-1],p[N-1]
                        15 = Complex time signal - amplitude/phase
                             a[0],p[0], ..., a[N-1],p[N-1]
                        16 = Real part of complex trace from 0 to Nyquist
                        17 = Imag part of complex trace from 0 to Nyquist
                        18 = Amplitude of complex trace from 0 to Nyquist
                        19 = Phase of complex trace from 0 to Nyquist
                        21 = Wavenumber time domain (k-t)
                        22 = Wavenumber frequency (k-omega)
                        23 = Envelope of the complex time trace
                        24 = Phase of the complex time trace
                        25 = Frequency of the complex time trace
                        30 = Depth-Range (z-x) traces
                        101 = Seismic data packed to bytes (by supack1)
                        102 = Seismic data packed to 2 bytes (by supack2)
                        */
        short nvs;      /* number of vertically summed traces (see vscode
                           in bhed structure) */
        short nhs;      /* number of horizontally summed traces (see vscode
                           in bhed structure) */
        short duse;     /* data use:
                                1 = production
                                2 = test */
        int offset;     /* distance from source point to receiver
                           group (negative if opposite to direction
                           in which the line was shot) */
        int gelev;      /* receiver group elevation from sea level
                           (above sea level is positive) */
        int selev;      /* source elevation from sea level
                           (above sea level is positive) */
        int sdepth;     /* source depth (positive) */
        int gdel;       /* datum elevation at receiver group */
        int sdel;       /* datum elevation at source */
        int swdep;      /* water depth at source */
        int gwdep;      /* water depth at receiver group */
        short scalel;   /* scale factor for previous 7 entries
                           with value plus or minus 10 to the
                           power 0, 1, 2, 3, or 4 (if positive,
                           multiply, if negative divide) */
        short scalco;   /* scale factor for next 4 entries
                           with value plus or minus 10 to the
                           power 0, 1, 2, 3, or 4 (if positive,
                           multiply, if negative divide) */
        int  sx;        /* X source coordinate */
        int  sy;        /* Y source coordinate */
        int  gx;        /* X group coordinate */
        int  gy;        /* Y group coordinate */
        short counit;   /* coordinate units code:
                                for previous four entries
                                1 = length (meters or feet)
                                2 = seconds of arc (in this case, the
                                X values are longitude and the Y values
                                are latitude, a positive value designates
                                the number of seconds east of Greenwich
                                or north of the equator */
        short wevel;    /* weathering velocity */
        short swevel;   /* subweathering velocity */
        short sut;      /* uphole time at source */
        short gut;      /* uphole time at receiver group */
        short sstat;    /* source static correction */
        short gstat;    /* group static correction */
        short tstat;    /* total static applied */
        short laga;     /* lag time A, time in ms between end of 240-
                           byte trace identification header and time
                           break, positive if time break occurs after
                           end of header, time break is defined as
                           the initiation pulse which maybe recorded
                           on an auxiliary trace or as otherwise
                           specified by the recording system */
        short lagb;     /* lag time B, time in ms between the time break
                           and the initiation time of the energy source,
                           may be positive or negative */
        short delrt;    /* delay recording time, time in ms between
                           initiation time of energy source and time
                           when recording of data samples begins
                           (for deep water work if recording does not
                           start at zero time) */
        short muts;     /* mute time--start */
        short mute;     /* mute time--end */
        unsigned short ns;      /* number of samples in this trace */
        unsigned short dt;      /* sample interval; in micro-seconds */
        short gain;     /* gain type of field instruments code:
                                1 = fixed
                                2 = binary
                                3 = floating point
                                4 ---- N = optional use */
        short igc;      /* instrument gain constant */
        short igi;      /* instrument early or initial gain */
        short corr;     /* correlated:
                                1 = no
                                2 = yes */
        short sfs;      /* sweep frequency at start */
        short sfe;      /* sweep frequency at end */
        short slen;     /* sweep length in ms */
        short styp;     /* sweep type code:
                                1 = linear
                                2 = cos-squared
                                3 = other */
        short stas;     /* sweep trace length at start in ms */
        short stae;     /* sweep trace length at end in ms */
        short tatyp;    /* taper type: 1=linear, 2=cos^2, 3=other */
        short afilf;    /* alias filter frequency if used */
        short afils;    /* alias filter slope */
        short nofilf;   /* notch filter frequency if used */
        short nofils;   /* notch filter slope */
        short lcf;      /* low cut frequency if used */
        short hcf;      /* high cut frequncy if used */
        short lcs;      /* low cut slope */
        short hcs;      /* high cut slope */
        short year;     /* year data recorded */
        short day;      /* day of year */
        short hour;     /* hour of day (24 hour clock) */
        short minute;   /* minute of hour */
        short sec;      /* second of minute */
        short timbas;   /* time basis code:
                                1 = local
                                2 = GMT
                                3 = other */
        short trwf;     /* trace weighting factor, defined as 1/2^N
                           volts for the least sigificant bit */
        short grnors;   /* geophone group number of roll switch
                           position one */
        short grnofr;   /* geophone group number of trace one within
                           original field record */
        short grnlof;   /* geophone group number of last trace within
                           original field record */
        short gaps;     /* gap size (total number of groups dropped) */
        short otrav;    /* overtravel taper code:
                                1 = down (or behind)
                                2 = up (or ahead) */
        /* local assignments */
        float d1;       /* sample spacing for non-seismic data */
        float f1;       /* first sample location for non-seismic data */
        float d2;       /* sample spacing between traces */
        float f2;       /* first trace location */
        float ungpow;   /* negative of power used for dynamic
                           range compression */
        float unscale;  /* reciprocal of scaling factor to normalize
                           range */
        int ntr;        /* number of traces */
        short mark;     /* mark selected traces */
        short unass[15];        /* unassigned--NOTE: last entry causes
                           a break in the word alignment, if we REALLY
                           want to maintain 240 bytes, the following
                           entry should be an odd number of short/UINT2
                           OR do the insertion above the "mark" keyword
                           entry */
} segy;
void ReadSegy(float **array, char inputname[], int ns, int ntr, int have)//ntr:trace num. ns:sample num.
{
	int ii,jj;
	FILE *pSegy=fopen(inputname,"rb");
	if(have)
		fseek(pSegy,3600L,0);
	for(ii=0;ii<ntr;ii++)
	{
		fseek(pSegy,240L,1);
		for(jj=0;jj<ns;jj++)
		{
			fread(&array[jj][ii],sizeof(float),1,pSegy);
		}
	}
	fclose(pSegy);
}
void WriteSegy(float **array, char outputname[],int ns, int ntr, float dt, float dx)//ntr:trace num. ns:sample num.
{
	int ii,jj;
	segy TraceHead;
	TraceHead.dt=(unsigned short)(dt*1e6);
	TraceHead.ns=(unsigned short)ns;
	FILE *pSegy=fopen(outputname,"wb");
//	fseek(pSegy,3600L,0);
	for(ii=0;ii<ntr;ii++)
	{
		TraceHead.tracf=ii+1;
		TraceHead.offset=ii*(int)dx;
		fwrite(&TraceHead,sizeof(segy),1,pSegy);
		for(jj=0;jj<ns;jj++)
		{
			fwrite(&array[jj][ii],sizeof(float),1,pSegy);
		}
	}
	fclose(pSegy);
}
int main()
{
	int jj,ii;
	int nx;
	int nt;
	int have;
	float dt;
	float dx;
	float xx=0;
	int cutj1,cutj2;
	char inname[50]={0};
	printf("input name: ");
	scanf("%s",inname);
	printf("nt=:(d) ");
	scanf("%d",&nt);
	printf("nx=:(d) ");
	scanf("%d",&nx);
	printf("dt=:(f) ");
	scanf("%f",&dt);
	printf("dx=:(f)");
	scanf("%f",&dx);
	printf("have=:(1 or 0) ");
	scanf("%d",&have);
	float **array=0;
	array=new float*[nt];
	for(jj=0;jj<nt;jj++)
		array[jj]=new float[nx];
	for(jj=0;jj<nt;jj++)
		for(ii=0;ii<nx;ii++)
			array[jj][ii]=0;
	ReadSegy(array, inname, nt, nx, have);
	printf("cutj=:(d)");
	scanf("%d",&cutj1);
	printf("cuti=:(d)");
	scanf("%d",&cutj2);
////cut
//	for(jj=0;jj<cutj1;jj++)
//		for(ii=0;ii<nx;ii++)
//			array[jj][ii]=0;
	for(jj=cutj1;jj<nt;jj++)
	{
		ii=0;
		xx=cutj2*(jj-cutj1)/(float)(nt-cutj1);
		while(ii<xx)
		{
			array[jj][ii]=0;
			ii++;
		}
	}
	WriteSegy(array, "cut.su",nt, nx, dt, dx);
	for(jj=0;jj<nt;jj++)
		delete[] array[jj];
	delete[] array;
	return 0;
}