/*
	kcomp.c

	reads klein '.dat' files and makes the '.phd' files
	then '.bhd' files.

*/
#include <stdio.h>
#include "getfile.c"
#include <math.h>

#define DP100M 0.0009009
#define DEG_RAD 0.01745329251				/* converts degrees to radians */
#define DEG_M   111120		/* converts degrees to meters -- 60 nmiles */
#define FILE_HEADER 5120
#define HEADER 32
#define DATA 404
#define TRAILER 4
#define NUMPTS 300
#define MAXHDR 300
#define PIXSIZE 0.5

int PrintAll=0;
int NumAvg=100,NumHdg=90; /* + or - points */

union intflo
{
	long lnum;
	float fnum;
};
struct r_header
{
	double lat,lon,time;
	unsigned char mo,da,yr,hr,min,sec,tsec;
	int pass_num,line_num,course,prp,corr_alt,uncorr_alt,rec_size;
	int status;
}Hdr[MAXHDR];
double nlat[NUMPTS],nlon[NUMPTS];
struct r_header dat[NUMPTS];
unsigned char Buffer[1024],DBuff[1024];
struct br_header
{
	double lat,lon;
	float heading,px,py;
	char mo,da,yr,hr,min,sec,tsec,status;
}B;
struct b_header
{
	double maxlat,minlat,maxlon,minlon;
	double pixsize;
	long row,col,file_hdr,line_hdr,line_data,line_tlr;
	int mean,min,perc10,perc25,median,perc75,perc90,max; /* pixel values */
	int numavg,numhdg;
	char space[96];	/* space for future expansion */
}C;
double Hist[256];
FILE *FpHdr;
double MaxLat,MinLat,MaxLon,MinLon,Row,Col;

main(argc,argv)

int argc;
char *argv[];

{
	int i,i1,j,k;
	int numfiles;
	int firstfile=0,lastfile;
	char ans;

	if(argc>1)
		for(i=1;i<argc;i++)
			if(argv[i][0]=='/'&&argv[i][1]=='p')
				PrintAll=1;

	if(argc>1)
		sscanf(argv[1],"%d",&firstfile);
	do
	{
		printf("\n\n   1 -- make lat lon ASCI file\n");
		printf("   2 -- make header files\n");
		printf("   3 -- list '.dat' files\n");
		ans=getch();
		if(ans=='1')
		{
			numfiles=load_names("kln*.dat");
			lastfile=numfiles-1;
			sort_name(numfiles);
			if(argc>2)
				for(i=1;i<argc;i++)
					if(argv[i][0]=='/'&&argv[i][1]=='s')
						lastfile=firstfile;
			for(i=firstfile;i<=lastfile;i++)
			{
				i1=GF_Order[i];
				printf("There are %d files.\n",numfiles);
				printf("%3d %s %9ld\n",i,GF_File[i1].name,GF_File[i1].size);
				make_asci_file(GF_File[i1].name);
			}
		}
		if(ans=='2')
		{
			numfiles=load_names("kln*.phd");
			lastfile=numfiles-1;
			sort_name(numfiles);
			if(argc>2)
				for(i=1;i<argc;i++)
					if(argv[i][0]=='/'&&argv[i][1]=='s')
						lastfile=firstfile;
			for(i=firstfile;i<=lastfile;i++)
			{
				i1=GF_Order[i];
				printf("%4d  %s\n",i,GF_File[i1].name);
				make_header_file(GF_File[i1].name);
			}
		}
		if(ans=='3')
		{
			numfiles=load_names("kln*.dat");
			sort_name(numfiles);
			for(i=0;i<numfiles;i++)
			{
				i1=GF_Order[i];
				printf("%4d %s\n",i,GF_File[i1].name);
			}
		}
	}while(ans!='x');
}



/***********************************************************************
**
**
**
**
************************************************************************/

int make_asci_file(name)

char *name;

{
	int i,j,k;
	FILE *fp,*fpout;
	int row,col;
	int file,num,val;
	unsigned char dbuff[32];
	long offset,hdr=FILE_HEADER;
	struct r_header dat;
	char string[100];
	double lat1,lon1,dist=0.0,dlat,dlon,fk,hnum,hsum,hsumo;

	for(i=0;i<256;i++)
		Hist[i]=0.0;
	sscanf(name+3,"%d",&file);
	fp=fopen(name,"rb");
	if(fp)
	{
		strcpy(string,name);
		for(k=0;k<strlen(string);k++)
			if(string[k]=='.')
				string[k]='\0';
		strcat(string,".phd");
		fpout=fopen(string,"wt");
		fread((char *)&row,sizeof(int),1,fp);
		fread((char *)&col,sizeof(int),1,fp);
		printf("row = %d\n",row);
		fprintf(fpout,"%d rows\n",row);
		fprintf(fpout,"%d cols\n",col);
		offset=hdr;
		fseek(fp,offset,SEEK_SET);
		for(i=0;i<row;i++)
		{
			if(kbhit()>0)
			{
				if(getch()==27)
				{
					fclose(fpout);
					fpout=fopen(string,"wt");
					exit(0);
				}
			}
			fread((char *)dbuff,sizeof(char),HEADER,fp);
			fread((char *)DBuff,sizeof(char),DATA+TRAILER,fp);
			decode_hdr(dbuff,&Hdr[0]);
			if(i==0)
			{
				for(j=0;j<DATA;j++)
				{
					val=DBuff[j];
					Hist[val]+=1.0;
				}
				lat1=Hdr[0].lat;
				lon1=Hdr[0].lon;
		fprintf(fpout,"%5d %10.6lf %11.6lf %2d %2d %2d %02d %02d %02d %1d\n",
					i+1,Hdr[0].lat,Hdr[0].lon,Hdr[0].mo,
					Hdr[0].da,Hdr[0].yr,Hdr[0].hr,Hdr[0].min,
					Hdr[0].sec,Hdr[0].tsec);
			}
			else
			{
				k=0;
				dist=(Hdr[0].lat-lat1)*(Hdr[0].lat-lat1)+
										(Hdr[0].lon-lon1)*(Hdr[0].lon-lon1);
				if(dist>1.0)
				{
					for(k=1;k<MAXHDR;k++)
					{
						if(k+i>=row)
						{
							printf("Bad data at end of file.  File truncated.\n");
							fclose(fpout);
							return(-2);
						}
						fread((char *)dbuff,sizeof(char),HEADER,fp);
						fread((char *)DBuff,sizeof(char),DATA+TRAILER,fp);
						decode_hdr(dbuff,&Hdr[k]);
						dist=(Hdr[k].lat-lat1)*(Hdr[k].lat-lat1)+
										(Hdr[k].lon-lon1)*(Hdr[k].lon-lon1);
						if(dist<1.0)
							break;
					}
					if(k>=MAXHDR-1)
					{
						printf("Too many bad points. File truncated.\n\n");
						return(-1);
					}
					printf("Fixing %d bad points\n",k);
					printf("from %10.6f %11.6f to %10.6lf %11.6lf\n",
						lat1,lon1,Hdr[k].lat,Hdr[k].lon);
					fk=k+1;
					dlat=(Hdr[k].lat-lat1)/fk;
					dlon=(Hdr[k].lon-lon1)/fk;
					for(j=0;j<k;j++)
					{
						lat1+=dlat;
						lon1+=dlon;
						printf("%5d %10.6lf %11.6lf %10.6lf %11.6lf\n",
							i+j,Hdr[j].lat,Hdr[j].lon,lat1,lon1);
						fprintf(fpout,
							"%5d %10.6lf %11.6lf %2d %2d %2d %02d %02d %02d %1d\n",
							-(i+j+1),lat1,lon1,Hdr[j].mo,
							Hdr[j].da,Hdr[j].yr,Hdr[j].hr,Hdr[j].min,
							Hdr[j].sec,Hdr[j].tsec);
					}
					i+=j;
					fprintf(fpout,
						"%5d %10.6lf %11.6lf %2d %2d %2d %02d %02d %02d %1d\n",
						i+1,Hdr[k].lat,Hdr[k].lon,Hdr[k].mo,
						Hdr[k].da,Hdr[k].yr,Hdr[k].hr,Hdr[k].min,
						Hdr[k].sec,Hdr[k].tsec);
				}
				else
				{
					lat1=Hdr[k].lat;
					lon1=Hdr[k].lon;
					if(
		fprintf(fpout,"%5d %10.6lf %11.6lf %2d %2d %2d %02d %02d %02d %1d\n",
						i+1,Hdr[0].lat,Hdr[0].lon,Hdr[0].mo,
						Hdr[0].da,Hdr[0].yr,Hdr[0].hr,Hdr[0].min,
						Hdr[0].sec,Hdr[0].tsec)<10)
							exit(0);
				}
			}
		}
		fclose(fpout);
		strcpy(string,name);
		for(k=0;k<strlen(string);k++)
			if(string[k]=='.')
				string[k]='\0';
		strcat(string,".thd");
		fpout=fopen(string,"wt");
		hsum=hnum=0.0;
		for(i=0;i<256;i++)
		{
			hnum+=Hist[i];
			hsum+=Hist[i]*(double)i;
		}
		if(hnum>0.0)
		{
			printf("mean   = %5.1lf\n",hsum/hnum);
			fprintf(fpout,"mean   = %5.1lf\n",hsum/hnum);
			hsumo=hsum=0.0;
			for(i=0;i<256;i++)
			{
				hsum+=Hist[i];
				if(hsumo==0.0&&hsum>0.0)
				{
					printf("min    = %3d\n",i);
					fprintf(fpout,"min    = %3d\n",i);
				}
				if(hsumo/hnum<0.10&&hsum/hnum>=0.10)
				{
					printf("perc10 = %3d\n",i);
					fprintf(fpout,"perc10 = %3d\n",i);
				}
				if(hsumo/hnum<0.25&&hsum/hnum>=0.25)
				{
					printf("perc25 = %3d\n",i);
					fprintf(fpout,"perc25 = %3d\n",i);
				}
				if(hsumo/hnum<0.50&&hsum/hnum>=0.50)
				{
					printf("perc50 = %3d\n",i);
					fprintf(fpout,"perc50 = %3d\n",i);
				}
				if(hsumo/hnum<0.75&&hsum/hnum>=0.75)
				{
					printf("perc75 = %3d\n",i);
					fprintf(fpout,"perc75 = %3d\n",i);
				}
				if(hsumo/hnum<0.90&&hsum/hnum>=0.90)
				{
					printf("perc90 = %3d\n",i);
					fprintf(fpout,"perc90 = %3d\n",i);
				}
				if(hsum==hnum)
				{
					printf("max    = %3d\n",i);
					fprintf(fpout,"max    = %3d\n",i);
					break;
				}
				hsumo=hsum;
			}
		}
		fclose(fpout);
	}

	fclose(fp);
}


/***********************************************************************
**
**
**
**
************************************************************************/

int make_header_file(name)

char *name;

{
	int i,j,k;
	FILE *fp,*fpthd;
	int row,col;
	int file,inum;
	unsigned char dbuff[32];
	union intflo dval;
	double lat,lon,time,num;
	long offset,hdr=FILE_HEADER;
	double dlat=0.0,dlon=0.0,dnum=0.0,dellat=0.0,dellon=0.0;
	double dx,dy,heading,dist,px,py;
	double distsum=0.0,distnum=0.0,distmax=-1.0,distmin=10000.0;
	char string[100],mo,da,yr,hr,min;
	float sec,mean;

	sscanf(name+3,"%d",&file);
	strcpy(string,name);
	for(k=0;k<strlen(string);k++)
		if(string[k]=='.')
			string[k]='\0';
	strcat(string,".thd");
	fpthd=fopen(string,"rt");

	fgets(string,99,fpthd);
	sscanf(string+8,"%f",&mean);
	mean+=0.5;
	printf("mean   = %3.0f\n",mean);
	C.mean=mean;

	fgets(string,99,fpthd);
	sscanf(string+8,"%f",&min);
	printf("min    = %3d\n",C.min);

	fgets(string,99,fpthd);
	sscanf(string+8,"%d",&C.perc10);
	printf("perc10 = %3d\n",C.perc10);

	fgets(string,99,fpthd);
	sscanf(string+8,"%d",&C.perc25);
	printf("perc25 = %3d\n",C.perc25);

	fgets(string,99,fpthd);
	sscanf(string+8,"%d",&C.median);
	printf("median = %3d\n",C.median);

	fgets(string,99,fpthd);
	sscanf(string+8,"%d",&C.perc75);
	printf("perc75 = %3d\n",C.perc75);

	fgets(string,99,fpthd);
	sscanf(string+8,"%d",&C.perc90);
	printf("perc90 = %3d\n",C.perc90);

	fgets(string,99,fpthd);
	sscanf(string+8,"%d",&C.max);
	printf("max    = %3d\n",C.max);

	fclose(fpthd);

	fp=fopen(name,"rb");
	if(fp)
	{
		strcpy(string,name);
		for(k=0;k<strlen(string);k++)
			if(string[k]=='.')
				string[k]='\0';
		strcat(string,".bhd");
		FpHdr=fopen(string,"rb");
		if(FpHdr)
		{
			printf("\n\nFile '%s' already exists.  Skipping file!\n\n",string);
			fclose(fp);
			fclose(FpHdr);
			return(-1);
		}
		else
			fclose(FpHdr);
		FpHdr=fopen(string,"wb");
		if(!FpHdr)
		{
			printf("Could not open '%s'\n",string);
			exit(0);
		}
		MaxLat=-1000.0;
		MinLat= 1000.0;
		MaxLon=-1000.0;
		MinLon= 1000.0;
		fwrite((char *)&C,sizeof(struct b_header),1,FpHdr);
		fscanf(fp,"%d%s",&row,string);
		fscanf(fp,"%d%s",&col,string);
		Row=row;
		Col=col;
		printf("row = %d  col = %d\n",row,col);
		i=0;
			fscanf(fp,"%d%lf%lf%d%d%d%d%d%d%d",
				&dat[(i)%NUMPTS].status,
				&dat[(i)%NUMPTS].lat,&dat[(i)%NUMPTS].lon,
				&dat[(i)%NUMPTS].mo,&dat[(i)%NUMPTS].da,
				&dat[(i)%NUMPTS].yr,&dat[(i)%NUMPTS].hr,
				&dat[(i)%NUMPTS].min,&dat[(i)%NUMPTS].sec);
		start_up(dat,nlat,nlon,&dlat,&dlon,fp,i,NumAvg,file);
		dnum=NumAvg*2+1;
		j=NumAvg;
		for(i=NumAvg+1;i<row-NumAvg;i++)
		{
			if(kbhit()>0)
			{
				if(getch()==27)
					exit(0);
			}
			fscanf(fp,"%d%lf%lf%d%d%d%d%d%d%d",
				&dat[(i+j)%NUMPTS].status,
				&dat[(i+j)%NUMPTS].lat,&dat[(i+j)%NUMPTS].lon,
				&dat[(i+j)%NUMPTS].mo,&dat[(i+j)%NUMPTS].da,
				&dat[(i+j)%NUMPTS].yr,&dat[(i+j)%NUMPTS].hr,
				&dat[(i+j)%NUMPTS].min,&dat[(i+j)%NUMPTS].sec);
			dlat+=dat[(i+j)%NUMPTS].lat;
			dlon+=dat[(i+j)%NUMPTS].lon;
			dlat-=dat[(i-j-1)%NUMPTS].lat;
			dlon-=dat[(i-j-1)%NUMPTS].lon;
			nlat[i%NUMPTS]=dlat/dnum;
			nlon[i%NUMPTS]=dlon/dnum;
			dy=(nlat[i%NUMPTS]-nlat[(i-1)%NUMPTS])*DEG_M;
			dx=(nlon[i%NUMPTS]-nlon[(i-1)%NUMPTS])*
						  cos(nlat[i%NUMPTS]*DEG_RAD)*DEG_M;
			dist=dx*dx+dy*dy;
			if(dist>0.0)
				dist=sqrt(dist);
			distsum+=dist;
			distnum+=1.0;
			if(dist>0.0)
			{
				if(dist>distmax)
					distmax=dist;
				if(dist<distmin)
					distmin=dist;
			}
			dy=(nlat[i%NUMPTS]-nlat[(i-NumHdg)%NUMPTS])*DEG_M;
			dx=(nlon[i%NUMPTS]-nlon[(i-NumHdg)%NUMPTS])*
					  cos(nlat[i%NUMPTS]*DEG_RAD)*DEG_M;
			dist=dx*dx+dy*dy;
			if(dist>0.0)
			{
				dist=sqrt(dist);
				px=-dy/dist;
				py= dx/dist;
				heading=atan2(dx,dy);
				if(heading<0.0)
					heading+=360.0*DEG_RAD;
			}
			B.lat=dlat/dnum;
			B.lon=dlon/dnum;
			B.mo=dat[(i)%NUMPTS].mo;
			B.da=dat[(i)%NUMPTS].da;
			B.yr=dat[(i)%NUMPTS].yr;
			B.hr=dat[(i)%NUMPTS].hr;
			B.min=dat[(i)%NUMPTS].min;
			B.sec=dat[(i)%NUMPTS].sec;
			B.tsec=dat[(i)%NUMPTS].tsec;
			B.heading=heading/DEG_RAD;
			B.px=px;
			B.py=py;
			if(dat[i%NUMPTS].status>0)
				B.status=1;
			else
				B.status=0;
			if(PrintAll==1)
printf(
"%d %9.6lf %10.6lf %9.6lf %10.6lf%5.2lf%5.2lf %4.2lf %5.1lf %5.2lf %5.2lf\n",
				B.status,
				dat[i%NUMPTS].lat,dat[i%NUMPTS].lon,
				dlat/dnum,dlon/dnum,dy,dx,dist,heading/DEG_RAD,px,py);
			fwrite((char *)&B,sizeof(struct br_header),1,FpHdr);
			if(B.lat>MaxLat)MaxLat=B.lat;
			if(B.lon>MaxLon)MaxLon=B.lon;
			if(B.lat<MinLat)MinLat=B.lat;
			if(B.lon<MinLon)MinLon=B.lon;
		}
		if(PrintAll==1)
printf("\n");
		close_down(dat,nlat,nlon,&dlat,&dlon,fp,row,NumAvg,file);
	}
	printf("mean dist = %7.3lf\n",distsum/distnum);
	printf("max = %7.3lf  min = %7.3lf\n",distmax,distmin);
	printf("number of points used = %0.0lf\n",distnum);
	rewind(FpHdr);
/*	load the structure */
	C.row=Row;
	C.col=Col;
	C.file_hdr=FILE_HEADER;
	C.line_hdr=HEADER;
	C.line_data=DATA;
	C.line_tlr=TRAILER;
	C.maxlat=MaxLat;
	C.minlat=MinLat;
	C.maxlon=MaxLon;
	C.minlon=MinLon;
	C.pixsize=PIXSIZE;
	C.numavg=NumAvg;
	C.numhdg=NumHdg;
	printf("row = %ld\n",C.row);
	printf("file_hdr = %ld\n",C.file_hdr);
	printf("line_hdr = %ld\n",C.line_hdr);
	printf("line_data = %ld\n",C.line_data);
	printf("line_tlr = %ld\n",C.line_tlr);
	printf("maxlat = %lf\n",C.maxlat);
	printf("minlat = %lf\n",C.minlat);
	printf("maxlon = %lf\n",C.maxlon);
	printf("minlon = %lf\n",C.minlon);
	printf("numavg = %d  numhdg = %d\n",C.numavg,C.numhdg);
	
	fwrite((char *)&C,sizeof(struct b_header),1,FpHdr);
	fclose(fp);
	fclose(FpHdr);
}



/***********************************************************************
**
**
**
**
************************************************************************/

int start_up(dat,nlat,nlon,dlat,dlon,fp,k,numavg,file)

	struct r_header *dat;
	double *nlat,*nlon;
	double *dlat,*dlon;
	FILE *fp;
	int k,numavg,file;

{
	int i,j;
	unsigned char dbuff[32];
	double dnum=0.0,dellat=0.0,dellon=0.0;
	double dx=0.0,dy=0.0,heading=0.0,dist=0.0,px=0.0,py=0.0;
	int inum;
	char string[100],mo,da,yr,hr,min;
	float sec;

	*dlat=*dlon=0.0;
	j=k;
	*dlat+=dat[j%NUMPTS].lat;
	*dlon+=dat[j%NUMPTS].lon;
	dnum+=1.0;
	nlat[j%NUMPTS]=*dlat;
	nlon[j%NUMPTS]=*dlon;
			B.lat=*dlat/dnum;
			B.lon=*dlon/dnum;
			B.mo=dat[(j)%NUMPTS].mo;
			B.da=dat[(j)%NUMPTS].da;
			B.yr=dat[(j)%NUMPTS].yr;
			B.hr=dat[(j)%NUMPTS].hr;
			B.min=dat[(j)%NUMPTS].min;
			B.sec=dat[(j)%NUMPTS].sec;
			B.tsec=dat[(j)%NUMPTS].tsec;
			B.heading=0.0;
			B.px=0.0;
			B.py=0.0;
			if(dat[i%NUMPTS].status>0)
				B.status=1;
			else
				B.status=0;
			if(PrintAll==1)
printf(
"*%d %9.6f %10.6f %9.6lf %10.6lf %4.2lf %4.2lf %4.2lf %5.1lf %5.2lf %5.2lf\n",
				B.status,
				dat[j%NUMPTS].lat,dat[j%NUMPTS].lon,
				*dlat/dnum,*dlon/dnum,dy,dx,dist,heading/DEG_RAD,px,py);
			fwrite((char *)&B,sizeof(struct br_header),1,FpHdr);
			if(B.lat>MaxLat)MaxLat=B.lat;
			if(B.lon>MaxLon)MaxLon=B.lon;
			if(B.lat<MinLat)MinLat=B.lat;
			if(B.lon<MinLon)MinLon=B.lon;
	for(i=1;i<=numavg;i++)
	{
		j=i*2-1+k;
			fscanf(fp,"%d%lf%lf%d%d%d%d%d%d%d",
				&dat[(j)%NUMPTS].status,
				&dat[(j)%NUMPTS].lat,&dat[(j)%NUMPTS].lon,
				&dat[(j)%NUMPTS].mo,&dat[(j)%NUMPTS].da,
				&dat[(j)%NUMPTS].yr,&dat[(j)%NUMPTS].hr,
				&dat[(j)%NUMPTS].min,&dat[(j)%NUMPTS].sec);
		*dlat+=dat[(j)%NUMPTS].lat;
		*dlon+=dat[(j)%NUMPTS].lon;
		dnum+=1.0;
		j=i*2+k;
			fscanf(fp,"%d%lf%lf%d%d%d%d%d%d%d",
				&dat[(j)%NUMPTS].status,
				&dat[(j)%NUMPTS].lat,&dat[(j)%NUMPTS].lon,
				&dat[(j)%NUMPTS].mo,&dat[(j)%NUMPTS].da,
				&dat[(j)%NUMPTS].yr,&dat[(j)%NUMPTS].hr,
				&dat[(j)%NUMPTS].min,&dat[(j)%NUMPTS].sec);
		*dlat+=dat[(j)%NUMPTS].lat;
		*dlon+=dat[(j)%NUMPTS].lon;
		dnum+=1.0;
		nlat[i%NUMPTS]=*dlat/dnum;
		nlon[i%NUMPTS]=*dlon/dnum;
		dy=(nlat[i%NUMPTS]-nlat[(i-1)%NUMPTS])*DEG_M;
		dx=(nlon[i%NUMPTS]-nlon[(i-1)%NUMPTS])*
					 cos(nlat[i%NUMPTS]*DEG_RAD)*DEG_M;
		dist=dx*dx+dy*dy;
		if(dist>0.0)
			dist=sqrt(dist);
		px=-dy/dist;
		py= dx/dist;
		heading=atan2(dx,dy);
		if(heading<0.0)
			heading+=360*DEG_RAD;
		if(PrintAll==1)
printf(
"%9.6f %10.6f %9.6lf %10.6lf %4.2lf %4.2lf %4.2lf %5.1lf %5.2lf %5.2lf\n",
				dat[i%NUMPTS].lat,dat[i%NUMPTS].lon,
				*dlat/dnum,*dlon/dnum,dy,dx,dist,heading/DEG_RAD,px,py);
			B.lat=*dlat/dnum;
			B.lon=*dlon/dnum;
			B.mo=dat[(i)%NUMPTS].mo;
			B.da=dat[(i)%NUMPTS].da;
			B.yr=dat[(i)%NUMPTS].yr;
			B.hr=dat[(i)%NUMPTS].hr;
			B.min=dat[(i)%NUMPTS].min;
			B.sec=dat[(i)%NUMPTS].sec;
			B.tsec=dat[(i)%NUMPTS].tsec;
			fwrite((char *)&B,sizeof(struct br_header),1,FpHdr);
			if(B.lat>MaxLat)MaxLat=B.lat;
			if(B.lon>MaxLon)MaxLon=B.lon;
			if(B.lat<MinLat)MinLat=B.lat;
			if(B.lon<MinLon)MinLon=B.lon;
	}
}

/***********************************************************************
**
**
**
**
***********************************************************************/

int close_down(dat,nlat,nlon,dlat,dlon,fp,row,numavg,file)

	struct r_header *dat;
	double *nlat,*nlon;
	double *dlat,*dlon;
	FILE *fp;
	int row,numavg,file;

{
	int i,j;
	unsigned char dbuff[32];
	double dnum=NumAvg*2+1,dellat=0.0,dellon=0.0;
	double dx,dy,heading,dist,px,py;

	j=row-NumAvg*2-1;
	for(i=row-NumAvg;i<row;i++)
	{
		*dlat-=dat[(j)%NUMPTS].lat;
		*dlon-=dat[(j)%NUMPTS].lon;
		j+=1;
		*dlat-=dat[(j)%NUMPTS].lat;
		*dlon-=dat[(j)%NUMPTS].lon;
		j+=1;
		dnum-=2.0;
		nlat[i%NUMPTS]=*dlat/dnum;
		nlon[i%NUMPTS]=*dlon/dnum;
		dy=(nlat[i%NUMPTS]-nlat[(i-1)%NUMPTS])*DEG_M;
		dx=(nlon[i%NUMPTS]-nlon[(i-1)%NUMPTS])*
					 cos(nlat[i%NUMPTS]*DEG_RAD)*DEG_M;
		dist=dx*dx+dy*dy;
		if(dist>0.0)
			dist=sqrt(dist);
		px=-dy/dist;
		py= dx/dist;
		heading=atan2(dx,dy);
		if(heading<0.0)
			heading+=360.0*DEG_RAD;
		if(PrintAll==1)
printf(
"%9.6lf %10.6lf %9.6lf %10.6lf %4.2lf %4.2lf %4.2lf %5.1lf %5.2lf %5.2lf\n",
				dat[i%NUMPTS].lat,dat[i%NUMPTS].lon,
				*dlat/dnum,*dlon/dnum,dy,dx,dist,heading/DEG_RAD,px,py);
		B.lat=*dlat/dnum;
		B.lon=*dlon/dnum;
		B.mo=dat[(i)%NUMPTS].mo;
		B.da=dat[(i)%NUMPTS].da;
		B.yr=dat[(i)%NUMPTS].yr;
		B.hr=dat[(i)%NUMPTS].hr;
		B.min=dat[(i)%NUMPTS].min;
		B.sec=dat[(i)%NUMPTS].sec;
		B.tsec=dat[(i)%NUMPTS].tsec;
		fwrite((char *)&B,sizeof(struct br_header),1,FpHdr);
		if(B.lat>MaxLat)MaxLat=B.lat;
		if(B.lon>MaxLon)MaxLon=B.lon;
		if(B.lat<MinLat)MinLat=B.lat;
		if(B.lon<MinLon)MinLon=B.lon;
	}
}


/***********************************************************************
**
**
**
**
************************************************************************/

int decode_hdr(dbuff,dat)

	unsigned char *dbuff;
	struct r_header *dat;

{
	int mo,da,yr,hr,min,sec;
	long tsec;
	union intflo dval;
	float lat,lon,time,test;
	int status=0;

	dval.lnum=dbuff[23];
	dval.lnum*=256;
	dval.lnum+=dbuff[22];
	dval.lnum*=256;
	dval.lnum+=dbuff[21];
	dval.lnum*=256;
	dval.lnum+=dbuff[20];
	dec2nec(&dval.lnum,1);
	if(fieeetomsbin(&dval.fnum,&test)!=0)
	{
		printf("Bad latitude\n");
		status-=1;
		lat=0.0;
	}
	else
		lat=dval.fnum;
	dval.lnum=dbuff[27];
	dval.lnum*=256;
	dval.lnum+=dbuff[26];
	dval.lnum*=256;
	dval.lnum+=dbuff[25];
	dval.lnum*=256;
	dval.lnum+=dbuff[24];
	dec2nec(&dval.lnum,1);
	if(fieeetomsbin(&dval.fnum,&test)!=0)
	{
		printf("Bad longitude\n");
		status-=1;
		lon=0.0;
	}
	else
		lon=dval.fnum;
	dval.lnum=dbuff[19];
	dval.lnum*=256;
	dval.lnum+=dbuff[18];
	dval.lnum*=256;
	dval.lnum+=dbuff[17];
	dval.lnum*=256;
	dval.lnum+=dbuff[16];
	dec2nec(&dval.lnum,1);
	if(fieeetomsbin(&dval.fnum,&test)!=0||dval.fnum>1.0e15)
	{
		printf("Bad time\n");
		status-=1;
		time=0.0;
	}
	else
		time=dval.fnum;
	min=time;
	sec=time*60;
	sec%=60;
	tsec=time*600;
	tsec%=10;
	mo=dbuff[9]*256+dbuff[8];
	da=dbuff[11]*256+dbuff[10];
	yr=dbuff[13]*256+dbuff[12];
	hr=dbuff[15]*256+dbuff[14];
	dat->pass_num=dbuff[1]*256+dbuff[0];
	dat->line_num=dbuff[3]*256+dbuff[2];
	dat->course=dbuff[5]*256+dbuff[4];
	dat->prp=dbuff[7]*256+dbuff[6];
	dat->lat=lat;
	dat->lon=lon;
	dat->time=time;
	dat->yr=yr;
	dat->mo=mo;
	dat->da=da;
	dat->hr=hr;
	dat->min=min;
	dat->sec=sec;
	dat->tsec=tsec;
	return(status);
}

/**************************************************************************
**
**
**
************************************************************************* */

int dec2nec(a,n)

long *a;
int n;

{
	long *w2;
	short i,j,z[2],y;

	w2=(long *)z;
	for(i=0;i<n;i++)
	{
		*w2=a[i];
		if((z[0]==0x8000)&&(z[1]==0x0000))
		{
			z[0]=0x0000;
			z[1]=0x7f80;
			a[i]=*w2;
		}
		if((z[0]==0x0000)&&(z[1]==0x0000))
		{
			z[0]=0x0000;
			z[1]=0x0000;
			a[i]=*w2;
		}
		else	/* good number */
		{
			y=z[0]-256;
			z[0]=z[1];
			z[1]=y;
			a[i]=*w2;
		}
	}
}