/*

		current.c

	crnt.bat = cl /AL current.c
	cd\current

	needs struct info changed to:

struct info
{
	int order;
	char name[20];
	char units[20];
	char codes[20];
	float depth;
	char inst[20];
	float min,max;
};

	before running on new data.

*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "font.h"
#include "nomouse.h"

#define NUM_DP 100
#define STR_LEN 100
#define NUMDAT 50
#define NUMCOM 10
#define NUMPTS 1000
#define CR 0xd
#define MAX_NUM 1000
#define S_SIZE 40
#define MAX_BUFF 32768
#define DEG_RAD 0.01745329251				/* converts degrees to radians */
#define MENU_C 4
#define MENUXC 550
#define NUMWTS 67
#define MAXVAR 25
#define MAXFRQ 385

#define BLACK 0
#define BACKGROUND 241
#define D_GREY 242 
#define M_GREY 243
#define L_GREY 244
#define WHITE 245
#define RED 246
#define ORANGE 247
#define YELLOW 248
#define GREEN 249
#define CYAN 250
#define BLUE 251
#define MAGENTA 252
#define BROWN 253
#define D_CYAN 254
#define D_BLUE 255

extern int LastN;
int Color_Val[16][3]=
{
	{  0,  0,  0}, /* BLACK */
	{105, 90, 75}, /* BACKGROUND */
	{ 64, 64, 64}, /* D_GREY */
	{100,100,100}, /* M_GREY */
	{160,160,160}, /* L_GREY */
	{255,255,255}, /* WHITE */
	{255,  0,  0}, /* RED */
	{255,128,  0}, /* ORANGE */
	{191,192,  0}, /* YELLOW */
	{  0,191,  0}, /* GREEN */
	{  0,191,191}, /* CYAN */
	{  0,  0,255}, /* BLUE */
	{191,  0,191}, /* MAGENTA */
	{ 96, 28, 14}, /* BROWN */
	{  0, 91, 91}, /* D_CYAN */
	{  0, 20, 60}  /* D_BLUE */
};
double Sx[MAXFRQ],Sy[MAXFRQ],Sxy[MAXFRQ],Sxx[MAXFRQ],Syy[MAXFRQ],Sn[MAXFRQ];
double S[MAXFRQ],R[MAXFRQ],B[MAXFRQ],Bs[MAXFRQ];
float RoseX[8]={ 0.000, 0.707, 1.000, 0.707, 0.000,-0.707,-1.000,-0.707};
float RoseY[8]={-1.000,-0.707, 0.000, 0.707, 1.000, 0.707 ,0.000,-0.707};
float Rose[32][20],RoseCum[8][20];
float RoseDSum[16],RoseSSum[20];
char *RoseDir[16]=
{
	"N  ","NNE","NE ","ENE",
	"E  ","ESE","SE ","SSE",
	"S  ","SSW","SW ","WSW",
	"W  ","WNW","NW ","NNW"
};
struct RoseLbl
{
	char *name;
	float x,y;
}Rl[8]=
{
	{"N",  0.000,-1.000},
	{"NE", 0.707,-0.707},
	{"E",  1.000,-0.000},
	{"SE", 0.707, 0.707},
	{"S",  0.000, 1.000},
	{"SW",-0.707, 0.707},
	{"W", -1.000,-0.000},
	{"NW",-0.707,-0.707}
};
float Fu[NUMWTS],Fv[NUMWTS];
float Filter[NUMWTS]=
{
  -2.7000000e-04, -1.1400000e-03, -2.1100000e-03, -3.1700000e-03,
  -4.2700000e-03, -5.3700000e-03, -6.4100000e-03, -7.3500000e-03,
  -8.1100000e-03, -8.6400000e-03, -8.8700000e-03, -8.7200000e-03,
  -8.1600000e-03, -7.1400000e-03, -5.6000000e-03, -3.5500000e-03,
  -9.7000000e-04,  2.1300000e-03,  5.7400000e-03,  9.8000000e-03,
   1.4250000e-02,  1.9020000e-02,  2.4000000e-02,  2.9110000e-02,
   3.4230000e-02,  3.9230000e-02,  4.3990000e-02,  4.8420000e-02,
   5.2370000e-02,  5.5760000e-02,  5.8500000e-02,  6.0510000e-02,
   6.1740000e-02,  6.2150000e-02,  6.1740000e-02,  6.0510000e-02,
   5.8500000e-02,  5.5760000e-02,  5.2370000e-02,  4.8420000e-02,
   4.3990000e-02,  3.9230000e-02,  3.4230000e-02,  2.9110000e-02,
   2.4000000e-02,  1.9020000e-02,  1.4250000e-02,  9.8000000e-03,
   5.7400000e-03,  2.1300000e-03, -9.7000000e-04, -3.5500000e-03,
  -5.6000000e-03, -7.1400000e-03, -8.1600000e-03, -8.7200000e-03,
  -8.8700000e-03, -8.6400000e-03, -8.1100000e-03, -7.3500000e-03,
  -6.4100000e-03, -5.3700000e-03, -4.2700000e-03, -3.1700000e-03,
  -2.1100000e-03, -1.1400000e-03, -2.7000000e-04
};
struct board
{
	int row,col,color;
}B_Id;
int I1=0,I2=255,S1=255,S2=255,H1=0;
float FCycle;
char *menu_c[MENU_C]= 
	{"change color","reset","grey scale","exit color"}; 
char *menu_sc[MAXVAR];
char Name[100];
extern char GF_String[MAX_NUM][S_SIZE];
FILE *FpIn,*FpOut;
char Text[260],Name[100];
unsigned char Header[512];
char String[20][100];
struct time
{
	int da,mo,yr,hr,min,sec;
};
struct time Time[NUMWTS];
char *Month[13]=
{
	"Err",
	"Jan","Feb","Mar","Apr","May","Jun",
	"Jul","Aug","Sep","Oct","Nov","Dec"
};
FILE *FpErr;
struct info
{
	int order;
	char name[20];
	char units[20];
	char codes[20];
	float depth;
	char inst[20];
	float min,max;
};
struct header
{
	char id[38];
	struct time start_time,stop_time;
	long cycles,num_days;
	char expt[32];
	char date_created[32];
	struct time time_create;
	float water_depth;					/* meters */
	float mag_var;							/* degrees */
	float lat,lon;							/* degrees */
	float sampling_interval;   		/* seconds */
	struct info Data[NUMDAT];
	char comment[NUMCOM][80];
	int num_var;
	int order[NUMDAT];
	char dummy[28];
/*
	 0 -- Time
	 1 -- Temp
	 2 -- Conductivity
	 3 -- Salinity
	 4 -- Led_Trans
	 5 -- Attenuation
	 6 -- U
	 7 -- V
	 8 -- U.2
	 9 -- V.2
	10 -- VDir
	11 -- VSpd
	12 -- Rotor_Speed
	13 -- Rotor_Count
	14 -- Vane
	15 -- Bearing
	16 -- Compass
	17 -- Pressure-I
	18 -- Pressure-B
	19 -- PSDev
	20 -- TransOn
	21 -- TransOff
	22 -- Neph
	23 -- NephOff
	24 -- Int-Rotor1
	25 -- Int-Rotor2
	26 -- R1-R2
	27 -- Burst-NUV
	28 -- BRotor/Rotor
	29 -- Ext_Coef
	30 -- Sigma_T
*/
}Hdr;
int NumPath=1;
char Path[NUM_DP][STR_LEN];

struct data_type
{
	int num_name;
	char *name[6];
}DType[NUMDAT]=
{
	{ 3,"t","time        ","Time"},
	{ 5,"T","temperature ","Temp","fr_temp","temperature"},
	{ 3,"C","conductivity","Conductivity"},
	{ 3,"S","salinity    ","Salinity"},
	{ 4,"L","Led Trans   ","Led_Trans","Led_Trans-Q"},

	{ 3,"A","attenuation ","Attenuation"},
	{ 5,"U","U (East)    ","U.1","U.1-Q","East"},
	{ 5,"V","V (North)   ","V.1","V.1-Q","North"},
	{ 4,"U","U.2         ","U.2","U.2-Q"},
	{ 4,"V","V.2         ","V.2","V.2-Q"},

	{ 4,"d","direction   ","VDir","VDir.1"},
	{ 4,"s","speed       ","VSpd","VSpd.1"},
	{ 3,"R","rotor speed ","Rotor_Speed"},
	{ 3,"R","rotor count ","Rotor_Count"},
	{ 3,"v","vane        ","Vane"},

	{ 3,"B","bearing     ","Bearing"},
	{ 4,"m","compass     ","Compass","Compass-Q"},
	{ 3,"p","pressure-I  ","Pressure-I"},
	{ 3,"p","pressure-B  ","Pressure-B"},
	{ 3,"p","PSDev       ","PSDev"},

	{ 4,"t","trans on    ","TransOn","TransOn-Q"},
	{ 4,"t","trans off   ","TransOff","TransOff-Q"},
	{ 4,"n","neph on     ","NephOn","NephOn-Q"},
	{ 4,"n","neph off    ","NephOff","NephOff-Q"},
	{ 5,"i","Int rotor 1 ","Int-Rotor1","IRotor1-Q","Int_Rotor1"},

	{ 5,"i","Int rotor 2 ","Int-Rotor2","IRotor2-Q","Int_Rotor2"},
	{ 2,"i","r1-r2       "},
	{ 3,"b","burst-NUV   ","Burst-NUV"},
	{ 3,"B","BRotor/Rotor","BRotor/Rotor"},
	{ 3,"e","Ext coef.   ","Ext_Coef"},

	{ 2,"D","Density","SigmaT"},
	{ 2,"T","FR_Temp","FR-Temp"},
	{ 2,"L","Trans2","Trans2-ATT"},
	{ 2,"T","Temp-Diff","Temp_Diff"},
	{ 1,"E","Err"},

	{ 1,"d","Rel_Sea_Leve"},
	{ 0," "},
	{ 0," "},
	{ 0," "},
	{ 0," "},

	{ 0," "},
	{ 0," "},
	{ 0," "},
	{ 0," "},
	{ 0," "},

	{ 0," "},
	{ 0," "},
	{ 0," "},
	{ 0," "},
	{ 0," "}
};
struct map_input
{
	char *name,type;
	double indat[6];
}miv;
struct map_screen
{
	int xc,yc,xs,ys;
}map_pos;
struct data
{
	struct time vtime;
	float data[NUMDAT];
}Data;
float Max[NUMDAT],Min[NUMDAT];
double Lat[NUMPTS],Lon[NUMPTS];
int Chosen[NUMPTS];
char VideoType='X',ImageSuffix[10],ImageScale=0,GreyScale=1,Scale;
int PicXc=320,PicXs=320,PicYc=480,PicYs=480;
int Black=0,White=255,L_Grey=191,M_Grey=128,D_Grey=46,Center=127;
int Red,Green,Orange,Yellow,Green,Cyan,Blue,Magenta;
int Num_Color=256;
int Sample,I_Sample;
int ScreenXs=640,ScreenYs=480,Reverse=0;
char Image[100],Lut[100],Pal_Type,Label[100],Color_Image;
struct   Color 
{ 
	unsigned char  r, g, b; 
}lut[256],lutm[256],lutc[256],luts[256]; 
struct color
{
	char *name;
	int r,g,b;
}Color[8]=
{
	{  "cyan",  0,255,255},
	{"yellow",200,200,  0},
	{   "red",255,  0,  0},
	{"orange",255,128,  0},
	{ "green",  0,255,  0},
	{  "blue",  0,  0,255},
	{"d_blue",  0, 20, 60},
	{ "brown", 96, 28, 14}
};
int Color_Lines=0;
unsigned char Vga_Color[256];
unsigned char Mbuff[MAX_BUFF],Buffer[4096];
unsigned char Inbuff[BUFSIZ],Inbuff2[BUFSIZ],Outbuff[BUFSIZ];
unsigned char DirHues[16][3]=
{
	255,  0,  0,
	255,108,  0,
	255,154,  0,
	255,202,  0,
	255,255,  0,
	209,255,  0,
	164,255,  0,
	116,255,  0,
	  0,255,  0,
	  0,255,204,
	  0,181,255,
	  0,106,255,
	 20, 20,255,
	 92,  0,255,
	154,  0,255,
	255,  0,217
};
unsigned char MaxHues[256][3]=
{
255,  0,  0,255, 32,  0,255, 42,  0,255, 53,  0,255, 60,  0,255, 68,  0,
255, 73,  0,255, 80,  0,255, 84,  0,255, 90,  0,255, 94,  0,255,100,  0,
255,103,  0,255,108,  0,255,112,  0,255,116,  0,255,121,  0,255,124,  0,
255,128,  0,255,132,  0,255,135,  0,255,139,  0,255,143,  0,255,146,  0,
255,150,  0,255,154,  0,255,157,  0,255,161,  0,255,164,  0,255,168,  0,
255,172,  0,255,176,  0,255,179,  0,255,183,  0,255,186,  0,255,190,  0,
255,194,  0,255,198,  0,255,202,  0,255,206,  0,255,210,  0,255,214,  0,
255,218,  0,255,222,  0,255,227,  0,255,231,  0,255,236,  0,255,241,  0,
255,245,  0,255,250,  0,254,255,  0,249,255,  0,244,255,  0,240,255,  0,
234,255,  0,229,255,  0,224,255,  0,220,255,  0,214,255,  0,209,255,  0,
204,255,  0,199,255,  0,194,255,  0,190,255,  0,184,255,  0,179,255,  0,
174,255,  0,169,255,  0,164,255,  0,158,255,  0,152,255,  0,147,255,  0,
141,255,  0,135,255,  0,130,255,  0,123,255,  0,116,255,  0,109,255,  0,
102,255,  0, 94,255,  0, 87,255,  0, 78,255,  0, 68,255,  0, 58,255,  0,
 42,255,  0, 23,255,  0,  0,255, 36,  0,255, 58,  0,255, 73,  0,255, 87,
  0,255,101,  0,255,113,  0,255,125,  0,255,135,  0,255,146,  0,255,156,
  0,255,166,  0,255,176,  0,255,186,  0,255,196,  0,255,204,  0,255,214,
  0,255,224,  0,255,233,  0,255,243,  0,255,252,  0,248,255,  0,239,255,
  0,230,255,  0,222,255,  0,214,255,  0,207,255,  0,200,255,  0,194,255,
  0,187,255,  0,181,255,  0,174,255,  0,169,255,  0,163,255,  0,157,255,
  0,152,255,  0,146,255,  0,141,255,  0,136,255,  0,131,255,  0,126,255,
  0,121,255,  0,116,255,  0,111,255,  0,106,255,  0,101,255,  0, 96,255,
  0, 92,255,  0, 86,255,  0, 81,255,  0, 77,255,  0, 71,255,  0, 66,255,
  0, 60,255,  0, 53,255,  0, 48,255,  0, 39,255,  0, 32,255,  0, 23,255,
  0,  0,255, 16,  0,255, 23,  0,255, 28,  0,255, 32,  0,255, 36,  0,255,
 39,  0,255, 42,  0,255, 45,  0,255, 48,  0,255, 50,  0,255, 53,  0,255,
 58,  0,255, 60,  0,255, 62,  0,255, 64,  0,255, 66,  0,255, 68,  0,255,
 70,  0,255, 73,  0,255, 75,  0,255, 77,  0,255, 78,  0,255, 81,  0,255,
 83,  0,255, 84,  0,255, 87,  0,255, 89,  0,255, 92,  0,255, 93,  0,255,
 94,  0,255, 97,  0,255, 98,  0,255,101,  0,255,103,  0,255,105,  0,255,
107,  0,255,109,  0,255,111,  0,255,113,  0,255,115,  0,255,117,  0,255,
119,  0,255,122,  0,255,124,  0,255,126,  0,255,129,  0,255,131,  0,255,
134,  0,255,135,  0,255,138,  0,255,140,  0,255,143,  0,255,145,  0,255,
148,  0,255,151,  0,255,154,  0,255,156,  0,255,160,  0,255,163,  0,255,
166,  0,255,169,  0,255,173,  0,255,176,  0,255,179,  0,255,183,  0,255,
188,  0,255,192,  0,255,196,  0,255,200,  0,255,204,  0,255,209,  0,255,
214,  0,255,220,  0,255,225,  0,255,231,  0,255,237,  0,255,244,  0,255,
250,  0,255,255,  0,252,255,  0,245,255,  0,238,255,  0,231,255,  0,224,
255,  0,217,255,  0,210,255,  0,203,255,  0,196,255,  0,190,255,  0,183,
255,  0,176,255,  0,170,255,  0,163,255,  0,156,255,  0,151,255,  0,144,
255,  0,137,255,  0,131,255,  0,125,255,  0,118,255,  0,112,255,  0,105,
255,  0, 98,255,  0, 90,255,  0, 83,255,  0, 77,255,  0, 68,255,  0, 60,
255,  0, 50,255,  0, 42,255,  0, 28,255,  0, 23
};
float MaxLat,MinLat,MaxLon,MinLon;

char fsplit(char *,char *,char *,char *);
FILE *p_open(char *name,char *format);

char limit_area_shape();
unsigned char getpt();
main(argc,argv)

int argc;
char *argv[];

{
	int i,j,k;
	char string[100],outfile[100],path[100];
	int numfile,lastchar,hit,chose,len;
	float i_depth;
	char ans,ans2,cr=0xd;
	int txc=ScreenXs/2,tyc=ScreenYs/2,txs=64,tys=ScreenYs/2,tspeed=16;
	FILE *fpin,*fpout;
	long num;

	if(argc>1)
	{
		for(i=0;i<argc;i++)
		{
			j=i+1;
			if(argv[j][0]=='/'&&(argv[j][1]=='X'||argv[j][1]=='x'))
				VideoType='X';
			if(argv[j][0]=='/'&&(argv[j][1]=='E'||argv[j][1]=='e'))
				VideoType='E';
			if(argv[j][0]=='/'&&(argv[j][1]=='V'||argv[j][1]=='v'))
				VideoType='V';
			if(argv[i][1]==':')
				add_disk_path(argv[i]);
			if(argv[i][0]=='\\')
				add_disk_path(argv[i]);
		}
	}
	i=GetVideoBoardID();
	if(VideoType=='E')
	{
		tyc=ScreenYs/2;
		tys=ScreenYs-1;
	}

	printf("structure size 'header' = %d\n\n",sizeof(struct header));
	printf("structure size 'data' = %d\n\n",sizeof(struct data));
	printf("structure size 'info' = %d\n\n",sizeof(struct info));
	set_range();
	LastN=0;
	do
	{
		printf("   c -- current rose\n");
		printf("   s -- scatter diagram\n");
		printf("\n   f -- spectral analysis of speed\n");
		printf("   u -- plot U and V\n");
		printf("   p -- progresive vector\n");
		printf("\n   L -- limit the active files\n");
		printf("   A -- output ASCII flat file on disk\n");
		printf("   H -- header check\n");
		printf("\n   x -- exit\n\n");
		ans=getch();
		if(ans=='c')
		{
			numfile=get_cur_name("*.cur",string);
			if(numfile>=0)
				current_rose(string);
		}
		if(ans=='H')
		{
			numfile=get_cur_name("*.cur",string);
			if(numfile>=0)
				header_check(string);
		}
		if(ans=='A')
		{
			numfile=get_cur_name("*.cur",string);
			if(numfile>=0)
			{
				FpIn=p_open(string,"rb");
				if(FpIn)
				{
					printf("Please give path (including disk drive) for output.\n");
					scanf("%s",path);
					if(strlen(path)>0&&path[1]!=':')
					{
						printf("'%s' is an invalid path.\n\n",path);
						exit(0);
					}
					if(path[strlen(path)-1]!='\\')
					{
						len=strlen(path);
						path[len]='\\';
						path[len+1]='\0';
					}
					i=0;
					fread((char *)&Hdr,sizeof(struct header),1,FpIn);
					strcpy(outfile,string);
					for(k=0;k<strlen(string);k++)
						if(string[k]=='.')
							string[k]='\0';
					sprintf(outfile,"%s%s.asc",path,string);
					fpout=p_open(outfile,"wt");
					if(!fpout)
					{
						printf("Could not open '%s'\n\n",outfile);
						exit(0);
					}
					fprint_header(Hdr,fpout);
					num=0;
					printf("       of %ld",Hdr.cycles);
					while(fread((char *)&Data.vtime,sizeof(struct time),1,FpIn)>0)
					{
						if(num%100==0)
							printf("%c%6ld",cr,num);
						fread((char *)Data.data,sizeof(float),Hdr.num_var-1,FpIn);
						if(fprintf(fpout,"%d-%02d-%02d %2d.%02d.%02d ",
							Data.vtime.yr,Data.vtime.mo,Data.vtime.da,
							Data.vtime.hr,Data.vtime.min,Data.vtime.sec)<6)
						{
							printf("Disk is full!!!!\n\n");
							fclose(fpout);
							exit(0);
						}
						for(j=0;j<Hdr.num_var-1;j++)
							fprintf(fpout," %10.5f",Data.data[j]);
						fprintf(fpout,"\n");
						num+=1;
					}
				}
			}
			fclose(FpIn);
			printf("\n");
			fclose(fpout);
		}
		if(ans=='u')
		{
			numfile=get_cur_name("*.cur",string);
			if(numfile>=0)
			{
				do
				{
					plot_uv(string);
					printf("\nPlot same file again?\n");
				}while(getch()=='y');
			}
		}
		if(ans=='p')
		{
			numfile=get_cur_name("*.cur",string);
			if(numfile>=0)
				continuous_uv(string);
		}
		if(ans=='s')
			scatter();
		if(ans=='f')
			spectral();
		if(ans=='L')
			set_range();
	}while(ans!='x'&&ans!=27);
}

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

int add_disk_path(string)

char *string;

{
	int i,j,k;
	char dsk,pth[STR_LEN],nam[10],typ[10],str[STR_LEN];
	int match,add=0;

	dsk=fsplit(string,pth,nam,typ);
	if(dsk>0)
		sprintf(str,"%c:%s",dsk,pth);
	else
		sprintf(str,"%s",pth);
	if((dsk>0||strlen(pth)>0)&&NumPath<NUM_DP)
	{
		match=0;
		for(i=0;i<NumPath;i++)
		{
			if(strcmpi(Path[i],str)==0)
				match=1;
		}
		if(match==0)
		{
			strcpy(Path[NumPath],str);
			NumPath+=1;
			add+=1;
		}
	}
	return(add);
}


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

char fsplit(instring,path,name,type)

char *instring,*path,*name,*type;

{
	int i,j,k;
	int dot=-1,last_slash=-1,len=strlen(instring),first_slash=-1;
	int num=0,colon=-1;
	int disk=0;
	char string[STR_LEN];

	strcpy(string,instring);
	path[0]='\0';
	name[0]='\0';
	type[0]='\0';

	for(i=0;i<len;i++)
	{
		if(string[i]==':')
			colon=i;
		else if(string[i]=='\\')
		{
			last_slash=i;
			if(first_slash<0)
				first_slash=i;
		}	
		else if(string[i]=='.')
			dot=i;
	}
	if(dot<0&&first_slash>=0&&last_slash<len-1)  /* d:test */
	{
		string[len]='\\';
		last_slash=len;
		len+=1;
		string[len]='\0';
	}
	if(dot<0&&first_slash<0&&len>colon-1)
	{
		string[len]='.';
		dot=len;
		len+=1;
		string[len]='\0';
	}
	if(colon>0)
		disk=string[0];
	if(first_slash>=0)
	{
		for(i=first_slash;i<=last_slash;i++)
			path[i-first_slash]=string[i];
		path[last_slash-first_slash+1]='\0';
	}
	if(last_slash>0&&last_slash<len-1&&dot>0)
	{
		for(i=last_slash+1;i<dot;i++)
			name[i-last_slash-1]=string[i];
		name[dot-last_slash-1]='\0';
	}
	if(colon>0&&last_slash<0&&dot>0)	/* d:test.img */
	{
		for(i=colon+1;i<dot;i++)
			name[i-colon-1]=string[i];
		name[dot-colon]='\0';
	}
	if(colon<0&&last_slash<0&&dot>0)	/* test.img */
	{
		for(i=0;i<dot;i++)
			name[i]=string[i];
		name[dot]='\0';
	}
	if(dot>0&&dot<len-1)
	{
		for(i=dot+1;i<len;i++)
			type[i-dot-1]=string[i];
		type[len-dot-1]='\0';
		if(strlen(type)>3)
			type[3]='\0';
	}
	return(disk);
}


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

FILE *p_open(char *name,char *format)

{
	int i,j,k;
	FILE *fp;
	char string[STR_LEN];
	int len;

	string[0]='\0';
	for(j=0;j<NumPath;j++)
	{
		len=strlen(Path[j])+strlen(name);
		if(len>0&&len<STR_LEN);
		{
			sprintf(string,"%s%s",Path[j],name);
			fp=fopen(string,format);
			if(fp)
				return(fp);
		}
	}
	clearerr(fp);
	fp=NULL;
	return(fp);
}




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

int header_check(char *string)

{
	int i,j,k;
	FILE *fp;

	fp=p_open(string,"rb");
	if(!fp)
		return(-1);
	fread((char *)&Hdr,sizeof(struct header),1,fp);
	print_header(Hdr);
	getch();
}



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

int spectral()

{
	int i,j,k,l,m,n;
	int numfile;
	char string[100],name[100];
	FILE *fpin;
	int iu,iv,id,is,ix,iy;
	float fi,fj,u,v,s;
	double heading,di,dl,dm;
	long maxfrq=MAXFRQ-1,numfrq,li=0,lj,lk;
 	double minpow=10000.0,maxpow=-1000000.0;
	int xc=ScreenXs/8,yc=ScreenYs/4,xs=3*ScreenXs/4,ys=ScreenYs/2;
	int ysm,ysmo,yp,ypo,xo;
	float fdx,fx,fy,freq,perd;
	char ans,cr=0xd;
	int fbx=xc,fby=yc+ys+30,pbx=ScreenXs/2,pby=fby,bxs=65,bys=18;

	numfile=get_cur_name("*.cur",string);
	if(numfile>=0)
	{
		strcpy(name,string);
		fpin=p_open(string,"rb");
		if(fpin)
		{
			fread((char *)&Hdr,sizeof(struct header),1,fpin);
			print_header(Hdr);
		}
		else
			return(-1);
	}
	else
		return(-1);
	if(fpin)
	{	
		printf(
"Give heading (0 or 360 = North, 90 = East, 180 = South and 270 = West)\n\n");
		scanf("%lf",&heading);
		fi=sin(heading*DEG_RAD);
		fj=cos(heading*DEG_RAD);
		printf("There are %d variables\n",Hdr.num_var);
		printf("unit vectors i = %7.4f   j = %7.4f\n",fi,fj);
		printf("Give number of points to use  ( maximum = %ld ).\n",maxfrq);
		scanf("%ld",&numfrq);
		if(numfrq<3)
		{
			printf("Too few points chosen!\n");
			return(-3);
		}
		if(numfrq>maxfrq)
		{
			printf("Adjusting number of points to %d.\n",maxfrq);
			numfrq=maxfrq;
		}
		iu=Hdr.Data[6].order-2;
		iv=Hdr.Data[7].order-2;
		id=Hdr.Data[10].order-2;
		printf("\n      of %ld",Hdr.cycles);
		while(fread((char *)&Data.vtime,sizeof(struct time),1,fpin)>0)
		{
			if(li%100==0)
				printf("%c%5ld",cr,li);
			fread((char *)Data.data,sizeof(float),Hdr.num_var-1,fpin);
			u=Data.data[iu];
			v=Data.data[iv];
			s=u*fi+v*fj;
			S[li%maxfrq]=s;
			if(li>=numfrq)
			{
				for(i=0;i<numfrq;i++)
				{
					lj=li-(i+1);
					j=lj%maxfrq;
					k=li%maxfrq;
					Sn[i]+=1.0;
					Sx[i]+=S[j];
					Sy[i]+=S[k];
					Sxy[i]+=S[j]*S[k];
					Sxx[i]+=S[j]*S[j];
					Syy[i]+=S[k]*S[k];
				}
			}
			li+=1;
		}
	}
	else
		return(-1);
	fclose(fpin);
	for(i=0;i<numfrq;i++)
	{
		if(Sn[i]>0.0)
		{
			R[i]=(Sxy[i]-Sx[i]/Sn[i]*Sy[i]/Sn[i])/
				  (sqrt(Sxx[i]-Sx[i]/Sn[i]*Sx[i]/Sn[i])*
					sqrt(Syy[i]-Sy[i]/Sn[i]*Sy[i]/Sn[i]));
		}
	}
	dm=numfrq;
	for(i=0;i<numfrq;i++)
	{
		if(i%2==0)
			B[i]=1.0/dm-R[numfrq-1]/dm;
		else
			B[i]=1.0/dm+R[numfrq-1]/dm;
		di=i+1;
		for(l=0;l<numfrq-1;l++)
		{
			dl=l+1;
			B[i]+=2.0/dm*R[l]*cos(360.0*DEG_RAD*di*dl/(2.0*dm));
		}
	}
	for(i=0;i<numfrq;i++)
	{
		if(B[i]>maxpow)
			maxpow=B[i];
		if(B[i]<minpow)
			minpow=B[i];
		if(i==0)
			Bs[i]=(2.0*B[i]+B[i+1])/3.0;
		else if(i==numfrq-1)
			Bs[i]=(2.0*B[i]+B[i-1])/3.0;
		else
			Bs[i]=(B[i-1]+2.0*B[i]+B[i+1])/4.0;
	}
	set_video_on();
	set_lut('D');
	paint_box(0,Blue-10,Buffer,0,0,ScreenXs,ScreenYs);
	paint_box(0,Black,Buffer,xc-15,yc+15,xs,ys);
	paint_box(0,Black,Mbuff,fbx-10,fby+10,bxs,bys);
	paint_box(0,Black,Mbuff,pbx-10,pby+10,bxs,bys);
	paint_box(0,Black,Mbuff,fbx+50,fby+50,bxs,bys);
	paint_box(0,Black,Mbuff,pbx-10,pby+50,bxs,bys);
	paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
	sprintf(string,"Freq.");
	plot_font_h(L_Grey,fbx-(strlen(string)+1)*7,fby+2,string,2,Font);
	sprintf(string,"Period");
	plot_font_h(L_Grey,pbx-(strlen(string)+1)*7,pby+2,string,2,Font);
	sprintf(string,"hours");
	plot_font_h(L_Grey,pbx+bxs+7,pby+2,string,2,Font);
	sprintf(string,"Power");
	plot_font_h(L_Grey,fbx+50-(strlen(string)+1)*7,fby+42,string,2,Font);
	sprintf(string,"Smoothed Power");
	plot_font_h(L_Grey,pbx-(strlen(string)+1)*7,pby+42,string,2,Font);

	paint_box(0,Black,Buffer,10,15,420,80);
	paint_box(0,D_Grey,Buffer,25,0,420,80);
	for(k=0;k<strlen(name);k++)
		if(name[k]=='.')
			name[k]='\0';
	sprintf(string,"File = %s  Lat. = %10.5f  Lon = %10.5f",
		name,Hdr.lat,Hdr.lon);
	plot_font_h(L_Grey,32,2,string,2,Font);
	sprintf(string,"Water Depth = %0.1f  Inst. Depth = %0.1f",
		Hdr.water_depth,Hdr.Data[6].depth);
	plot_font_h(L_Grey,32,22,string,2,Font);
	sprintf(string,"Number of Records = %ld",Hdr.cycles);
	plot_font_h(L_Grey,32,42,string,2,Font);
	sprintf(string,"Heading = %0.1lf degrees",heading);
	plot_font_h(L_Grey,32,62,string,2,Font);
	fdx=(float)xs/(float)(numfrq-1);
	fx=0.0;
	for(i=0;i<numfrq;i++)
	{
		ix=fx;
		fx+=fdx;
		fy=(maxpow-B[i])/(maxpow-minpow)*(float)ys;
		yp=iy=fy;
		plotpt(0,xc+ix,yc+iy,Black);
		ysm=fy=(maxpow-Bs[i])/(maxpow-minpow)*(float)ys;
		iy=fy;
		plotpt(0,xc+ix,yc+iy,White);
		if(i>0)
		{
			plotln(0,xc+xo,yc+ypo,xc+ix,yc+yp,Black);
			plotln(0,xc+xo,yc+ysmo,xc+ix,yc+ysm,L_Grey);
		}
		ypo=yp;
		ysmo=ysm;
		xo=ix;
	}
	fx=0;
	i=ix=0;
	tplotln_val(0,xc+ix,yc,xc+ix,yc+ys-1,Buffer,Red);
	di=i+1;
	dm=numfrq;
	sprintf(string,"%6d",i+1);
	paint_box(0,D_Grey,Mbuff,fbx,fby,bxs,bys);
	plot_font_h(L_Grey,fbx+2,fby+2,string,2,Font);
	perd=2.0*dm*Hdr.sampling_interval/3600.0/di;
	sprintf(string,"%8.3f",perd);
	paint_box(0,D_Grey,Mbuff,pbx,pby,bxs,bys);
	plot_font_h(L_Grey,pbx+2,pby+2,string,2,Font);

	sprintf(string,"%8.5lf",B[i]);
	paint_box(0,D_Grey,Mbuff,fbx+60,fby+40,bxs,bys);
	plot_font_h(L_Grey,fbx+62,fby+42,string,2,Font);
	sprintf(string,"%8.5lf",Bs[i]);
	paint_box(0,D_Grey,Mbuff,pbx,pby+40,bxs,bys);
	plot_font_h(L_Grey,pbx+2,pby+42,string,2,Font);

	do
	{
		ans=getch();
		if(ans==0)
		{
			ans=getch();
			if(ans==24)	/* Alt o */
				output_screen(0,0,ScreenXs,ScreenYs);
			unplotln(0,xc+ix,yc,xc+ix,yc+ys-1,Buffer);
			if(i>0&&ans==75)
				i-=1;
			if(i<numfrq-1&&ans==77)
				i+=1;
			ix=fdx*(float)i;
			tplotln_val(0,xc+ix,yc,xc+ix,yc+ys-1,Buffer,Red);
			di=i+1;
			dm=numfrq;
			sprintf(string,"%6d",i+1);
			paint_box(0,D_Grey,Mbuff,fbx,fby,bxs,bys);
			plot_font_h(L_Grey,fbx+2,fby+2,string,2,Font);
			perd=2.0*dm*Hdr.sampling_interval/3600.0/di;
			sprintf(string,"%8.3f",perd);
			paint_box(0,D_Grey,Mbuff,pbx,pby,bxs,bys);
			plot_font_h(L_Grey,pbx+2,pby+2,string,2,Font);

			sprintf(string,"%8.5lf",B[i]);
			paint_box(0,D_Grey,Mbuff,fbx+60,fby+40,bxs,bys);
			plot_font_h(L_Grey,fbx+62,fby+42,string,2,Font);
			sprintf(string,"%8.5lf",Bs[i]);
			paint_box(0,D_Grey,Mbuff,pbx,pby+40,bxs,bys);
			plot_font_h(L_Grey,pbx+2,pby+42,string,2,Font);

		}
	}while(ans!=27);
	unplotln(0,xc+ix,yc,xc+ix,yc+ys-1,Buffer);
	SetVideoMode(0);
}

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

int current_rose(name)

char *name;

{
	int i,j,k,iu,iv,id,is,ix,iy,it,speed=16,k1,k2,k3,k4,m;
	int ii,jj,lx[5],ly[5];
	int jd,js;
	FILE *fpin;
	int cycle,val,mo,moo,ival,rval;
	float maxspd=70.0,spd,dir,fcycle,fj;
	float tmax,tmin,temp,delt,scale=.1;
	char string[100],cr=0xd,*form,*space;
	int x1,x2,y1,y2,maxjs=0;
	float fx1,fx2,fy1,fy2,u,v,h,s;
	float maxx,minx,maxy,miny,xscale,yscale,rnum=0.0;
	int xc=(ScreenXs-ScreenYs)/2,yc=0;
	int xs=ScreenYs-15,ys=ScreenYs-15,cx,cy;
	float flen,x10,y10,dx,dy;
	int px1,px2,px3,py1,py2,py3;
	long li=0;

	strcpy(Name,name);
	for(i=0;i<32;i++)
		for(j=0;j<20;j++)
			Rose[i][j]=0.0;
	for(i=0;i<8;i++)
		for(j=0;j<20;j++)
			RoseCum[i][j]=0.0;
	for(i=0;i<16;i++)
		RoseDSum[i]=0.0;
	for(j=0;j<20;j++)
		RoseSSum[j]=0.0;
	printf("input file = '%s'\n",name);
	fpin=p_open(name,"rb");
	if(fpin)
	{	
		fread((char *)&Hdr,sizeof(struct header),1,fpin);
		print_header(Hdr);
		printf("There are %d variables\n",Hdr.num_var);
		iu=Hdr.Data[6].order-2;
		iv=Hdr.Data[7].order-2;
		id=Hdr.Data[10].order-2;
		is=Hdr.Data[11].order-2;
		it=Hdr.Data[ 1].order-2;
		if(id<0||is<0)
			return(-1);
		maxspd=Hdr.Data[11].max;
		tmin=Hdr.Data[1].min;
		tmax=Hdr.Data[1].max;
		delt=tmax-tmin;
		if(delt<=0.0)
			it=-1;
		i=j=0;
		fj=0.0;
		mo=moo=-1;
		printf("\n      of %ld",Hdr.cycles);
		while(fread((char *)&Data.vtime,sizeof(struct time),1,fpin)>0)
		{
			fread((char *)Data.data,sizeof(float),Hdr.num_var-1,fpin);
			if(++li%100==0)
				printf("%c%5ld",cr,li);
			u=Data.data[iu];
			v=Data.data[iv];
			h=Data.data[id];
			s=Data.data[is];
			jd=(h+11.25)/22.5;
			if(jd>15)
				jd=0;
			k=h/11.25;
			if(k>31)
				k-=32;
			if(k<0)
				k+=32;
			js=s/5.0;
			if(js>19)
				js=19;
			RoseDSum[jd]+=1;
			RoseSSum[js]+=1;
			Rose[k][js]+=1;
			rnum+=1;
			if(js>maxjs)
				maxjs=js;
		}
		if(rnum<=0.0)
			return(-2);
		printf("\n  ");
		if(maxjs>15)
		{
			form="%3.0f";
			space="   ";
		}
		else
		{
			form="%4.0f";
			space="    ";
		}
		for(js=0;js<=maxjs+1;js++)
			printf("%3d",js*5);
	printf("\n\nTwo-way Frequency Distribution of Current and Direction\n\n");
		for(jd=0;jd<16;jd++)
		{
			k1=jd*2;
			k2=k1-1;
			if(k2<0)
				k2+=32;
			printf("%s ",RoseDir[jd]);
			for(js=0;js<=maxjs;js++)
			{
				if(Rose[k1][js]+Rose[k2][js]>0.0)
					printf(form,
						(Rose[k1][js]+Rose[k2][js])/rnum*1000.0);
				else
					printf(space);
			}
			printf(" %4.0f\n",RoseDSum[jd]/rnum*1000.0);
		}
		printf("\n    ");
		for(js=0;js<=maxjs;js++)
			printf(form,RoseSSum[js]/rnum*1000.0);
		printf(" 1000\nHit Any Key to Continue.");
getch();
		printf("\n");
printf("\n\nCummulative Two-way Frequency Distribution for Current Rose\n\n");
		for(i=0;i<8;i++)
		{
			for(j=0;j<20;j++)
			{
				if(i>0)
				{
					k3=i*4;
					k1=k3-2;
					k2=k3-1;
					k4=k3+1;
				}
				else
				{
					k3=0;
					k1=30;
					k2=31;
					k4=1;
				}
				for(m=0;m<=j;m++)
					RoseCum[i][j]+=
						Rose[k1][m]+Rose[k2][m]+Rose[k3][m]+Rose[k4][m];
			}
		}
		for(i=0;i<8;i++)
		{
			printf("%s",RoseDir[i*2]);
			for(j=0;j<20;j++)
			{
				RoseCum[i][j]*=100.0/rnum;
				printf("%3.0f",RoseCum[i][j]);
			}
			printf("\n");
		}					
	}
	printf("Hit Any Key to Continue.\n");
	fclose(fpin);
	getch();
	set_video_on();
	set_lut('D');
	cx=xc+xs/2;
	cy=yc+ys/2;
	paint_box(0,Red-10,Buffer,0,0,xc,15);
	paint_box(0,Red-10,Buffer,0,15,xc-15,ys);
	paint_box(0,Red-10,Buffer,xc+xs,0,ScreenXs-xc-xs,ys);
	paint_box(0,Red-10,Buffer,xc+xs-15,ys,ScreenXs-xc-xs+15,15);
	paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
	box(0,xc,yc,L_Grey,xs-1,ys-1);
	for(k=0;k<strlen(name);k++)
		if(name[k]=='.')
			name[k]='\0';
	sprintf(string,"File = %s  Lat. = %10.5f  Lon = %10.5f",
		name,Hdr.lat,Hdr.lon);
	plot_font_h(L_Grey,xc+4,yc+4,string,2,Font);
	sprintf(string,"Water Depth = %0.1f  Inst. Depth = %0.1f",
		Hdr.water_depth,Hdr.Data[6].depth);
	plot_font_h(L_Grey,xc+4,yc+24,string,2,Font);
	sprintf(string,"Number of Records = %ld",Hdr.cycles);
	plot_font_h(L_Grey,xc+4,yc+44,string,2,Font);
	sprintf(string,">= 0 & <15");
	plot_font_h(Blue,xc+4,yc+64,string,2,Font);
	sprintf(string,">=15 & <30");
	plot_font_h(Red,xc+4,yc+84,string,2,Font);
	sprintf(string,">=30");
	plot_font_h(Yellow,xc+4,yc+104,string,2,Font);
	cursor(0,cx,cy,White,5);
	sprintf(string,"USGS Current Rose");
	plot_font_h(Black,xc+4,yc+ys-25,string,1,Font);
	plot_font_h(M_Grey,xc+8,yc+ys-29,string,1,Font);
	x10=xs/12;
	y10=ys/12;
	for(i=0;i<8;i++)
	{
		ix=x10*4.3*Rl[i].x;
		iy=x10*4.3*Rl[i].y;
		iy-=5;
		ix-=strlen(Rl[i].name)*7/2;
		plot_font_h(White,cx+ix,cy+iy,Rl[i].name,2,Font);
	}
	for(i=0;i<(int)x10*4;i++)
	{
		flen=sqrt((double)(x10*x10*16)-(double)(i*i));
		for(k=1;k<5;k++)
		{
			ii=i*k;
			ii/=4;
			jj=flen/4.0*(float)k;
			plotpt(0,cx+ii,cy+jj,Black);
			plotpt(0,cx+ii,cy-jj,Black);
			plotpt(0,cx-ii,cy+jj,Black);
			plotpt(0,cx-ii,cy-jj,Black);
			plotpt(0,cx+jj,cy+ii,Black);
			plotpt(0,cx+jj,cy-ii,Black);
			plotpt(0,cx-jj,cy+ii,Black);
			plotpt(0,cx-jj,cy-ii,Black);	
			if(i==(int)(x10*1.52))
			{
				lx[k]=ii;
				ly[k]=jj;
			}
		}
	}
	for(i=1;i<5;i++)
	{
		sprintf(string,"0.%d",i);
		plot_font_h(L_Grey,cx-lx[i]-7,cy+ly[i]-3,string,3,Font);
		plot_font_h(L_Grey,cx+lx[i]-7,cy-ly[i]-4,string,3,Font);
	}
	for(i=0;i<8;i++)
	{
		flen=RoseCum[i][19]/10;
		dx=RoseX[i]*flen*x10;
		dy=RoseY[i]*flen*y10;
		px3=ix=cx+dx;
		py3=iy=cy+dy;
		flen=RoseCum[i][5]/10;
		dx=RoseX[i]*flen*x10;
		dy=RoseY[i]*flen*y10;
		px2=ix=cx+dx;
		py2=iy=cy+dy;
		flen=RoseCum[i][2]/10;
		dx=RoseX[i]*flen*x10;
		dy=RoseY[i]*flen*y10;
		px1=ix=cx+dx;
		py1=iy=cy+dy;
		plotln(0,cx,cy,ix,iy,Blue);
		if(RoseCum[i][5]!=RoseCum[i][2])
		{
			iy= RoseX[i]*y10/15;
			ix=-RoseY[i]*x10/15;
			plotln(0,px1+ix,py1+iy,px1-ix,py1-iy,Red);
			plotln(0,px2+ix,py2+iy,px2-ix,py2-iy,Red);
			plotln(0,px1+ix,py1+iy,px2+ix,py2+iy,Red);
			plotln(0,px1-ix,py1-iy,px2-ix,py2-iy,Red);
		}
		if(RoseCum[i][5]!=RoseCum[i][19])
		{
			iy= RoseX[i]*y10/7;
			ix=-RoseY[i]*x10/7;
			plotln(0,px2+ix,py2+iy,px2-ix,py2-iy,Yellow);
			plotln(0,px3+ix,py3+iy,px3-ix,py3-iy,Yellow);
			plotln(0,px2+ix,py2+iy,px3+ix,py3+iy,Yellow);
			plotln(0,px2-ix,py2-iy,px3-ix,py3-iy,Yellow);
		}
	}
	if(getch()==0)
		if(getch()==24)	/* Alt o */
			output_screen(0,0,ScreenXs,ScreenYs);
	SetVideoMode(0);

}

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

int scatter()

{
	int i,j,k,n1,n2,n3,i1,i2,i3,x,y;
	int num1=0,num2,num3,numfile,val,ival,rval;
	char string[100],name[100],ans;
	float max1,max2,max3,min1,min2,min3,del1,del2,del3;
	float scale=ScreenYs-15,temp;
	int xc=ScreenXs-ScreenYs+15,yc=0,xs=ScreenYs-15,ys=ScreenYs-15;
	int cx=xs/2,cy=ys/2,speed=16;
	float v1,v2,v3,vn3,dx,dy,fx,fy,fi;
	int x1,x2,y1,y2,bs=5,len;
	char *xform,*yform;

	numfile=get_cur_name("*.cur",string);
	if(numfile>=0)
	{
		FpIn=p_open(string,"rb");
		if(FpIn)
			fread((char *)&Hdr,sizeof(struct header),1,FpIn);
		else
			return(-1);
	}
	else
		return(-1);
	for(j=0;j<Hdr.num_var;j++)
	{
		i=Hdr.order[j];
		menu_sc[j]=Hdr.Data[i].name;
	}
	set_video_on();
	set_lut('D');
	paint_box(0,Orange-10,Buffer,0,0,xc,15);
	paint_box(0,Orange-10,Buffer,0,15,xc-15,ys);
	paint_box(0,Orange-10,Buffer,ScreenXs-15,ScreenYs-15,15,15);
	paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
	box(0,xc,yc,L_Grey,xs-1,ys-1);
	plot_font_h(L_Grey,ScreenXs/2,5,"Choose X axis",2,Font);
	num1=do_menu_buff(menu_sc,Hdr.num_var,MENUXC,25,num1,
					D_Grey,L_Grey,White,Font);
	paint_box(0,D_Grey,Buffer,ScreenXs/2,5,120,15);
	plot_font_h(L_Grey,ScreenXs/2,5,"Choose Y axis",2,Font);
	num2=do_menu_buff(menu_sc,Hdr.num_var,MENUXC,25,num1,
					D_Grey,L_Grey,White,Font);
	paint_box(0,D_Grey,Buffer,ScreenXs/2,5,120,15);
	plot_font_h(L_Grey,ScreenXs/2,5,"Choose Z (color) axis",2,Font);
	num3=do_menu_buff(menu_sc,Hdr.num_var,MENUXC,25,num2,
					D_Grey,L_Grey,White,Font);
	paint_box(0,D_Grey,Buffer,ScreenXs/2,5,155,15);
	n1=num1-1;
	n2=num2-1;	
	n3=num3-1;
	i1=Hdr.order[num1];
	i2=Hdr.order[num2];
	i3=Hdr.order[num3];
	strcpy(name,string);
	for(k=0;k<strlen(name);k++)
		if(name[k]=='.')
			name[k]='\0';
	sprintf(string,"File = %s",name);
	plot_font_h(L_Grey,2,2,string,2,Font);
	sprintf(string,"Lat %10.5f",Hdr.lat);
	plot_font_h(L_Grey,2,22,string,2,Font);
	sprintf(string,"Lon %10.5f",Hdr.lon);
	plot_font_h(L_Grey,2,42,string,2,Font);
	sprintf(string,"Water Depth %0.1f",Hdr.water_depth);
	plot_font_h(L_Grey,2,62,string,2,Font);
	sprintf(string,"Inst. Depth %0.1f",Hdr.Data[i1].depth);
	plot_font_h(L_Grey,2,82,string,2,Font);
	sprintf(string,"# Records %ld",Hdr.cycles);
	plot_font_h(L_Grey,2,102,string,2,Font);
	max1=Hdr.Data[i1].max;
	min1=Hdr.Data[i1].min;
	max2=Hdr.Data[i2].max;
	min2=Hdr.Data[i2].min;
	max3=Hdr.Data[i3].max;
	min3=Hdr.Data[i3].min;
	sprintf(string,"X = %s",Hdr.Data[i1].name);
	plot_font_h(White,2,122,string,2,Font);
	sprintf(string,"Min/Max %0.2f/%0.2f",min1,max1);
	plot_font_h(L_Grey,2,142,string,2,Font);
	sprintf(string,"          %s",Hdr.Data[i1].units);
	plot_font_h(L_Grey,2,162,string,2,Font);
	paint_box(0,D_Grey,Buffer,2,160,63,15);
	box(0,1,159,L_Grey,64,16);
	sprintf(string,"Y = %s",Hdr.Data[i2].name);
	plot_font_h(White,2,182,string,2,Font);
	sprintf(string,"Min/Max %0.2f/%0.2f",min2,max2);
	plot_font_h(L_Grey,2,202,string,2,Font);
	sprintf(string,"          %s",Hdr.Data[i2].units);
	plot_font_h(L_Grey,2,222,string,2,Font);
	paint_box(0,D_Grey,Buffer,2,220,63,15);
	box(0,1,219,L_Grey,64,16);
	sprintf(string,"Z = %s",Hdr.Data[i3].name);
	plot_font_h(White,2,242,string,2,Font);
	sprintf(string,"Min/Max %0.2f/%0.2f",min3,max3);
	plot_font_h(L_Grey,2,282,string,2,Font);
	sprintf(string,"          %s",Hdr.Data[i3].units);
	plot_font_h(L_Grey,2,302,string,2,Font);
	paint_box(0,D_Grey,Buffer,2,300,63,15);
	box(0,1,299,L_Grey,64,16);
	del1=max1-min1;
	del2=max2-min2;
	del3=max3-min3;
	if(strcmpi(Hdr.Data[i1].units,Hdr.Data[i2].units)==0) /* rescale? */
	{
		if(del1>del2)
		{
			max2+=(del1-del2)/2.0;
			min2-=(del1-del2)/2.0;
			del2=del1;
		}
		else
		{
			max1+=(del2-del1)/2.0;
			min1-=(del2-del1)/2.0;
			del1=del2;
		}
	}
	if(del1<=0.0||del2<=0.0)
	{
		fclose(FpIn);
		SetVideoMode(0);
		return(-2);
	}
	dx=0.0001;
	while(del1/dx>10)
		dx*=10.0;
	while(del1/dx<4)
		dx/=2.0;
	dy=0.0001;
	while(del2/dy>10)
		dy*=10.0;
	while(del1/dy<4)
		dy/=2.0;
	xform="%0.0f";
	yform="%0.0f";
	if(dx<1.0)
		xform="%0.1f";
	if(dx<0.3)
		xform="%0.2f";
	if(dx<0.03)
		xform="%0.3f";
	if(dx<0.003)
		xform="%0.4f";
	if(dx<0.0003)
		xform="%0.5f";
	if(dy<3.0)
		yform="%0.1f";
	if(dy<0.3)
		yform="%0.2f";
	if(dy<0.03)
		yform="%0.3f";
	if(dy<0.003)
		yform="%0.4f";
	if(dy<0.0003)
		yform="%0.5f";
	del1/=scale;
	del2/=scale;
	fx=dx;
	while(fx<max1||-fx>min1)
	{
		x=(fx*i-min1)/del1;
		if(x>=0&&x<xs)
		{
			plotln(0,xc+x,yc+1,xc+x,yc+ys-2,Black);
			sprintf(string,xform,fx);
			len=strlen(string)*5/2;
			if(x-len>0&&x+len<xs)
			{
				plot_font_h(L_Grey,xc+x-len,yc+ys-10,string,3,Font);
				plot_font_h(L_Grey,xc+x-len,yc+2,string,3,Font);
			}
		}
		x=(-fx-min1)/del1;
		if(x>=0&&x<xs)
		{
			plotln(0,xc+x,yc+1,xc+x,yc+ys-2,Black);
			sprintf(string,xform,fx);
			len=strlen(string)*5/2;
			if(x-len>0&&x+len<xs)
			{
				plot_font_h(L_Grey,xc+x-len,yc+ys-10,string,3,Font);
				plot_font_h(L_Grey,xc+x-len,yc+2,string,3,Font);
			}
		}
		fx+=dx;
	}
	fy=dy;
	while(fy<max2||-fy>min2)
	{
		y=(max2-fy)/del2;
		if(y>=0&&y<ys)
		{
			plotln(0,xc+1,yc+y,xc+xs-2,yc+y,Black);
			sprintf(string,yform,fy);
			len=strlen(string)*5;
			if(y>6&&y<ys-6)
			{
				plot_font_h(L_Grey,xc+2,yc+y-5,string,3,Font);
				plot_font_h(L_Grey,xc+xs-len-2,yc+y-5,string,3,Font);
			}
		}
		y=(max2+fy)/del2;
		if(y>=0&&y<ys)
		{
			plotln(0,xc+1,yc+y,xc+xs-2,yc+y,Black);
			sprintf(string,yform,fy);
			len=strlen(string)*5;
			if(y>6&&y<ys-6)
			{
				plot_font_h(L_Grey,xc+2,yc+y-5,string,3,Font);
				plot_font_h(L_Grey,xc+xs-len-2,yc+y-5,string,3,Font);
			}
		}
		fy+=dy;
	}
	x=(0.0-min1)/del1;
	y=(max2-0.0)/del2;
	if(x>=0&&x<xs)
		plotln(0,xc+x,yc,xc+x,yc+ys-1,L_Grey);
	if(y>=0&&y<ys)
		plotln(0,xc,yc+y,xc+xs-1,yc+y,L_Grey);
	for(i=0;i<127;i++)
	{
		val=127-i;
		ival=val/8;
		rval=val%8;
		val=ival*15+14-rval;
		Buffer[i]=val;
	}
	for(i=0;i<10;i++)
		plotrow(0,2,128,264+i,Buffer);
	while(fread((char *)&Data.vtime,sizeof(struct time),1,FpIn)>0)
	{
		fread((char *)Data.data,sizeof(float),Hdr.num_var-1,FpIn);
		x=(Data.data[n1]-min1)/del1;
		y=(max2-Data.data[n2])/del2;
		temp=Data.data[n3];
		temp=(max3-temp)/del3*127;
		val=temp;
		ival=val/8;
		rval=val%8;
		val=ival*15+14-rval;
		plotpt(0,xc+x,yc+y,val);
	}
	tplotln_val(0,xc,yc+cy,xc+xs-1,yc+cy,Buffer,Red);
	tplotln_val(0,xc+cx,yc,xc+cx,yc+ys-1,Buffer+1024,Red);
	do
	{
		ans=getch();
		unplotln(0,xc+cx,yc,xc+cx,yc+ys-1,Buffer+1024);
		unplotln(0,xc,yc+cy,xc+xs-1,yc+cy,Buffer);
		if(ans==0)
		{
			ans=getch();
			if(ans==24)	/* Alt o */
			{
				tplotln_val(0,xc,yc+cy,xc+xs-1,yc+cy,Buffer,Red);
				tplotln_val(0,xc+cx,yc,xc+cx,yc+ys-1,Buffer+1024,Red);
				output_screen(0,0,ScreenXs,ScreenYs);
				unplotln(0,xc+cx,yc,xc+cx,yc+ys-1,Buffer+1024);
				unplotln(0,xc,yc+cy,xc+xs-1,yc+cy,Buffer);
			}
			if(ans==71||ans==72||ans==73)
				cy-=speed;
			if(ans==79||ans==80||ans==81)
				cy+=speed;
			if(ans==71||ans==75||ans==79)
				cx-=speed;
			if(ans==73||ans==77||ans==81)
				cx+=speed;
			if(cx<0)
				cx=0;
			if(cx>=xs)
				cx=xs-1;
			if(cy<0)
				cy=0;
			if(cy>=ys)
				cy=ys-1;
		}
		if(ans=='-'&&speed>1)
			speed/=2;
		if(ans=='+'&&speed<64)
			speed*=2;
		v1=(float)cx*del1+min1;
		v2=max2-(float)cy*del2;
		sprintf(string,"%9.2f",v1);
		paint_box(0,D_Grey,Buffer,2,160,63,15);
		plot_font_h(L_Grey,2,162,string,2,Font);
		sprintf(string,"%9.2f",v2);
		paint_box(0,D_Grey,Buffer,2,220,63,15);
		plot_font_h(L_Grey,2,222,string,2,Font);
		x1=cx-bs;
		x2=cx+bs;
		y1=cy-bs;
		y2=cy+bs;
		if(x1<0)
			x1=0;
		if(x2>=xs)
			x2=xs-1;
		if(y1<0)
			y1=0;
		if(y2>=ys)
			y2=ys-1;
		x1+=xc;x2+=xc;y1+=yc;y2+=yc;
		v3=vn3=0.0;
		for(i=x1;i<=x2;i++)
		{
			for(j=y1;j<=y2;j++)
			{
				val=getpt(0,i,j);
				if(val>0&&val<240)
				{
					ival=val/15;
					rval=val%15;
					val=ival*8+14-rval;
					v3+=val;
					vn3+=1.0;
				}
			}
		}
		paint_box(0,D_Grey,Buffer,2,300,63,15);
		if(vn3>0.0)
		{
			v3=max3-v3/vn3/127.0*del3;
			sprintf(string,"%9.2f",v3);
			plot_font_h(L_Grey,2,302,string,2,Font);
		}
		tplotln_val(0,xc,yc+cy,xc+xs-1,yc+cy,Buffer,Red);
		tplotln_val(0,xc+cx,yc,xc+cx,yc+ys-1,Buffer+1024,Red);
	}while(ans!=27&&ans!=13);

	SetVideoMode(0);
	fclose(FpIn);
}



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

int fprint_header(hdr,fpout)

struct header hdr;
FILE *fpout;

{
	int i,j,k;

	fprintf(fpout,"%s",Hdr.id);
	for(k=0;k<15-strlen(Hdr.id);k++)
		fprintf(fpout," ");
	fprintf(fpout,"start time = %2d %s 19%2d  %02d:%02d:%02d",
		Hdr.start_time.da,Month[Hdr.start_time.mo],
		Hdr.start_time.yr,Hdr.start_time.hr,
		Hdr.start_time.min,Hdr.start_time.sec);
	fprintf(fpout,"  cycles = %ld\n",Hdr.cycles);
	fprintf(fpout,"               stop  time = %2d %s 19%2d  %02d:%02d:%02d",
		Hdr.stop_time.da,Month[Hdr.stop_time.mo],
		Hdr.stop_time.yr,Hdr.stop_time.hr,
		Hdr.stop_time.min,Hdr.stop_time.sec);
	fprintf(fpout,"  # days = %ld\n",Hdr.num_days);
	fprintf(fpout,"Expt. = '%s'  ",Hdr.expt);
	fprintf(fpout,"sampling interval = %0.2f minutes\n",
		Hdr.sampling_interval/60.0);
	fprintf(fpout,"Lat = %10.6f\n",Hdr.lat);
	fprintf(fpout,"Lon = %10.6f  File created: %s\n",
		Hdr.lon,Hdr.date_created);
	fprintf(fpout,"depth = %0.0fm  Mag.var = %10.6f\n",
		Hdr.water_depth,Hdr.mag_var);
	fprintf(fpout,
"#  Variable     Units        Codes Depth   Inst.   Minimum   Maximum\n");
fprintf(fpout,
"-- ------------ ------------ ----- ------- ------ --------- ---------\n");
	for(j=0;j<Hdr.num_var;j++)
	{
		i=Hdr.order[j];

		fprintf(fpout,"%2d ",Hdr.Data[i].order);
		fprintf(fpout,"%s",Hdr.Data[i].name);
		if(strlen(Hdr.Data[i].name)<13)
			for(k=0;k<13-strlen(Hdr.Data[i].name);k++)
				fprintf(fpout," ");
		fprintf(fpout,"%s",Hdr.Data[i].units);
		if(strlen(Hdr.Data[i].units)<13)
			for(k=0;k<13-strlen(Hdr.Data[i].units);k++)
				fprintf(fpout," ");
		fprintf(fpout,"%s",Hdr.Data[i].codes);
		if(strlen(Hdr.Data[i].codes)<6)
			for(k=0;k<6-strlen(Hdr.Data[i].codes);k++)
				fprintf(fpout," ");
		if(Hdr.Data[i].depth!=0.0||
				Hdr.Data[i].min!=0.0||
				Hdr.Data[i].max!=0.0||
				strlen(Hdr.Data[i].inst)>0)
		{
			fprintf(fpout,"%7.2f ",Hdr.Data[i].depth);
			fprintf(fpout,"%s",Hdr.Data[i].inst);
			if(strlen(Hdr.Data[i].inst)<6)
				for(k=0;k<6-strlen(Hdr.Data[i].inst);k++)
					fprintf(fpout," ");
			fprintf(fpout,"%10.3f",Hdr.Data[i].min);
			fprintf(fpout,"%10.3f\n",Hdr.Data[i].max);
		}
		else
			fprintf(fpout,"\n");
	}
fprintf(fpout,
"---------------------------------------------------------------------\n");
	for(k=0;k<NUMCOM;k++)
		if(strlen(Hdr.comment[k])>0)
			fprintf(fpout,"%s\n",Hdr.comment[k]);
}

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

int continuous_uv(name)

char *name;

{
	int i,j,k,iu,iv,id,is,ix,iy,it,speed=16;
	FILE *fpin;
	int cycle,val,mo,moo,ival,rval;
	float maxspd=70.0,spd,dir,fcycle,fj;
	float tmax,tmin,temp,delt,scale=.1;
	char string[100],cr=0xd;
	int x1,x2,y1,y2;
	float fx1,fx2,fy1,fy2,u,v;
	float maxx,minx,maxy,miny,xscale,yscale;
	long num=0;

	strcpy(Name,name);
	minx=maxx=fx1=fx2=0.0;
	miny=maxy=fy1=fy2=0.0;

	printf("input file = '%s'\n",name);
	fpin=p_open(name,"rb");
	if(fpin)
	{	
		fread((char *)&Hdr,sizeof(struct header),1,fpin);
		print_header(Hdr);
		printf("There are %d variables\n",Hdr.num_var);
		iu=Hdr.Data[6].order-2;
		iv=Hdr.Data[7].order-2;
		id=Hdr.Data[10].order-2;
		is=Hdr.Data[11].order-2;
		it=Hdr.Data[ 1].order-2;
		if(id<0||is<0)
			return(-1);
		maxspd=Hdr.Data[11].max;
		tmin=Hdr.Data[1].min;
		tmax=Hdr.Data[1].max;
		delt=tmax-tmin;
		if(delt<=0.0)
			it=-1;
		i=j=0;
		fj=0.0;
		mo=moo=-1;
		printf("\n\nCalculating plot size.\n");
		printf("\n      of %ld",Hdr.cycles);
		while(fread((char *)&Data.vtime,sizeof(struct time),1,fpin)>0)
		{
			if(num%100==0)
				printf("%c%6ld",cr,num);
			num+=1;
			fread((char *)Data.data,sizeof(float),Hdr.num_var-1,fpin);
			u=Data.data[iu];
			v=Data.data[iv];
			fx1+=u;
			fy1-=v;
			if(fx1>maxx)maxx=fx1;
			if(fx1<minx)minx=fx1;
			if(fy1>maxy)maxy=fy1;
			if(fy1<miny)miny=fy1;
		}
		xscale=(float)ScreenXs/(maxx-minx);
		yscale=(float)ScreenYs/(maxy-miny);
		scale=xscale;
		if(yscale<scale)
			scale=yscale;
		scale*=0.9;
		fx1=(0-minx)+scale*0.05;
		fy1=(0-miny)+scale*0.05;
		set_video_on();
		set_lut('D');
		if(it>=0)
			plot_temp_key(ScreenXs-240,ScreenYs-195,tmin,tmax);
		rewind(fpin);
		fread((char *)&Hdr,sizeof(struct header),1,fpin);
		while(fread((char *)&Data.vtime,sizeof(struct time),1,fpin)>0)
		{

			mo=Data.vtime.mo;
			if(mo!=moo&&i>0)
				plotln(0,i,cycle+1,i,cycle+25,M_Grey);
			if(mo!=moo&&Data.vtime.da<5)
			{
				cursor(0,x1,y1,White,7);
				sprintf(string,"%s",Month[Data.vtime.mo]);
				plot_font_h(L_Grey,x1+2,y1+2,string,2,Font);
				sprintf(string,"%2d",Data.vtime.yr);
				plot_font_h(L_Grey,x1+2,y1+22,string,2,Font);
			}
			moo=mo;
			fread((char *)Data.data,sizeof(float),Hdr.num_var-1,fpin);
			u=Data.data[iu];
			v=Data.data[iv];
			x2=fx1*scale;
			y2=fy1*scale;
			fx1+=u;
			fy1-=v;
			x1=fx1*scale;
			y1=fy1*scale;
			temp=Data.data[it];
			temp=(tmax-temp)/delt*96;
			val=temp;
			ival=val/8;
			rval=val%8;
			val=ival*15+14-rval;
			plotln(0,x1,y1,x2,y2,val);
		}
		if(getch()==0)
			if(getch()==24)	/* Alt o */
				output_screen(0,0,ScreenXs,ScreenYs);
		SetVideoMode(0);
	}
}

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

int plot_uv_key(xc,yc)

int xc,yc;

{
	int i,j,k;
	int xs=160,ys=190;
	int d,s,xcent=xc+xs/2,ycent=yc+xs/2+30;
	FILE *fpkey;
	double dx,dy,spd,dir;

	fpkey=p_open("velocity.key","rb");

	if(!fpkey)
	{
		fpkey=p_open("velocity.key","wb");
		paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
		for(i=-75;i<76;i++)
		{
			dx=i;
			dx/=5.0;
			for(j=-75;j<76;j++)
			{
				dy=j;
				dy/=5.0;
				if(dx!=0.0||dy!=0.0)
				{
					spd=sqrt(dy*dy+dx*dx);
					s=spd;
					dir=atan2(dx,dy);
					dir/=DEG_RAD;
					if(dir<0.0)dir+=360.0;
					if(dir>360.0)dir-=360;
					dir=(dir+11.25)/22.5;
					d=dir;
					if(d>15)d=0;
					if(s<15)
					{
						plotpt(0,xcent+i,ycent-j,d*15+s+1);
					}
				}
				else
					plotpt(0,xcent,ycent,Black+1);
			}
		}
		fwrite((char *)&ys,sizeof(int),1,fpkey);
		fwrite((char *)&xs,sizeof(int),1,fpkey);
		for(i=0;i<ys;i++)
		{
			getrow(0,xc,xc+xs-1,yc+i,Buffer);
			fwrite((char *)Buffer,sizeof(char),xs,fpkey);
		}
		fclose(fpkey);
	}
	else
	{
		fread((char *)&ys,sizeof(int),1,fpkey);
		fread((char *)&xs,sizeof(int),1,fpkey);
		for(i=0;i<ys;i++)
		{
			fread((char *)Buffer,sizeof(char),xs,fpkey);
			plotrow(0,xc,xc+xs-1,yc+i,Buffer);
		}
		fclose(fpkey);
	}
}


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

int plot_uv(name)

char *name;

{
	int i,j,k,iu,iv,id,is,ix,iy,it,speed=16;
	FILE *fpin;
	int cycle,val,mo,moo,ival,rval;
	float maxspd=70.0,spd,dir,fcycle,fj;
	float tmax,tmin,temp,delt;
	char string[100];
	int x1,x2,y1,y2;

	strcpy(Name,name);
	x1=y1=0;

	printf("input file = '%s'\n",name);
	fpin=p_open(name,"rb");
	if(name[0]=='A')
		cycle=192;
	else
		cycle=24;
	if(fpin)
	{	
		fread((char *)&Hdr,sizeof(struct header),1,fpin);
		print_header(Hdr);
		printf("There are %d variables\n",Hdr.num_var);
		iu=Hdr.Data[6].order-2;
		iv=Hdr.Data[7].order-2;
		id=Hdr.Data[10].order-2;
		is=Hdr.Data[11].order-2;
		it=Hdr.Data[ 1].order-2;
		if(id<0||is<0)
			return(-1);
		maxspd=Hdr.Data[11].max;
		tmin=Hdr.Data[1].min;
		tmax=Hdr.Data[1].max;
		delt=tmax-tmin;
		if(delt<=0.0)
			it=-1;
		fcycle=cycle;
		printf("cycle = %0.2f.  Do you want to change it?  (y or n)\n",fcycle);
		if(getch()=='y')
		{
			printf("Give new value for cycles per day.\n");
			scanf("%f",&fcycle);
			cycle=fcycle;
		}
		FCycle=fcycle;
		y2=cycle+1;
		set_video_on();
		set_lut('D');
		if(it>=0)
			plot_temp_key(ScreenXs-240,ScreenYs-195,tmin,tmax);
		plot_uv_key(ScreenXs-165,ScreenYs-195);
		sprintf(string,"Maximum Speed");
		plot_font_h(White,ScreenXs-163,ScreenYs-193,string,2,Font);
		sprintf(string,"%0.3f %s",maxspd,Hdr.Data[11].units);
		plot_font_h(White,ScreenXs-163,ScreenYs-178,string,2,Font);
		i=j=0;
		fj=0.0;
		mo=moo=-1;
		while(fread((char *)&Data.vtime,sizeof(struct time),1,fpin)>0)
		{
			mo=Data.vtime.mo;
			if(mo!=moo&&i>0)
				plotln(0,i,cycle+1,i,cycle+25,M_Grey);
			if(mo!=moo&&Data.vtime.da<5)
			{
				sprintf(string,"%s",Month[Data.vtime.mo]);
				plot_font_h(L_Grey,i+2,cycle+5,string,2,Font);
				sprintf(string,"%2d",Data.vtime.yr);
				plot_font_h(L_Grey,i+2,cycle+20,string,2,Font);
			}
			moo=mo;
			fread((char *)Data.data,sizeof(float),Hdr.num_var-1,fpin);
			spd=Data.data[is];
			spd=spd/maxspd*15.0;
			if(spd>15.0)spd=15.0;
			dir=Data.data[id];
			val=(dir+11.25)/22.5;
			if(val>15)val=0;
			val*=15;
			val+=spd;
			j=fj;
			plotpt(0,i,j,val+1);
			if(it>=0)
			{
				temp=Data.data[it];
				temp=(tmax-temp)/delt*96;
				val=temp;
				ival=val/8;
				rval=val%8;
				val=ival*15+14-rval;
				plotpt(0,i,j+cycle+40,val);
			}
			x2=i;
			fj+=1.0;
			if(fj>fcycle)
			{
				fj-=fcycle;
				i+=1;
			}
		}
		fclose(fpin);
		ix=30;
		iy=fcycle/2.0;
		find_velocity(&ix,&iy,&speed,x1,x2,y1,y2);
		SetVideoMode(0);
	}
}

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

int find_velocity(x,y,spd,x1,x2,y1,y2)

int *x,*y,*spd,x1,x2,y1,y2;

{
	int i,j,k;
	int color[3],cnum;
	int ix=*x,iy=*y,ixo=*x,iyo=*y,speed=*spd;
	char ans,string[50];
	float fx,fy,ftime;
	long ltime,ljday0,ljday,lyday;
	int yr,mo,da,hr,jday,jday0,yr0,mo0,da0,hr0,yday,min,sec,samrate;
	int xmax=x2,ymax=y2,cycle=FCycle,timeplot=0;

	tcursor_val(0,ix,iy,7,Buffer,White,White,White);
	cnum=getpt(0,ix,iy);
	color[0]=lut[cnum].r;color[1]=lut[cnum].g;color[2]=lut[cnum].b;
	lut[cnum].r=lut[cnum].g=lut[cnum].b=White;
	WritePalette(lut); 
	yr0=Hdr.start_time.yr;
	mo0=Hdr.start_time.mo;
	da0=Hdr.start_time.da;
	hr0=Hdr.start_time.hr;
	jday0=day_of_year(yr0,mo0,da0);
	ljday0=(long)jday0*86400+(long)hr0*3600
				+(long)Hdr.start_time.min*60+(long)Hdr.start_time.sec;
	do
	{
		ans=getch();
		if(ans=='-'&&speed>1)
			speed/=2;
		if(ans=='+'&&speed<256)
			speed*=2;
		if(ans=='s'||ans=='S')
		{
			uncursor(0,ixo,iyo,7,Buffer);
			lut[cnum].r=color[0];lut[cnum].g=color[1];lut[cnum].b=color[2];
			WritePalette(lut); 
			scan_velocity(x1,x2,y1,y2);
			tcursor_val(0,ix,iy,7,Buffer,White,White,White);
		}
		if(ans==0)
		{
			ans=getch();
			if(ans==24)	/* Alt o */
				output_screen(0,0,ScreenXs,ScreenYs);
			if(ans==71||ans==72||ans==73)
				iy-=speed;
			if(ans==79||ans==80||ans==81)
				iy+=speed;
			if(ans==71||ans==75||ans==79)
				ix-=speed;
			if(ans==73||ans==77||ans==81)
				ix+=speed;
			if(ix<0)
				ix=0;
			if(iy<0)
				iy=0;
			if(ix>=ScreenXs)
				ix=ScreenXs-1;
			if(iy>=ScreenYs)
				iy=ScreenYs-1;
			uncursor(0,ixo,iyo,7,Buffer);
			lut[cnum].r=color[0];lut[cnum].g=color[1];lut[cnum].b=color[2];
			WritePalette(lut); 
			cnum=getpt(0,ix,iy);
			color[0]=lut[cnum].r;color[1]=lut[cnum].g;color[2]=lut[cnum].b;
			lut[cnum].r=lut[cnum].g=lut[cnum].b=White;
			if(cnum>0)
				WritePalette(lut); 
			tcursor_val(0,ix,iy,7,Buffer,White,White,White);
			ixo=ix;iyo=iy;
		}
		if(ans=='c')
		{
			uncursor(0,ixo,iyo,7,Buffer);
			lut[cnum].r=color[0];lut[cnum].g=color[1];lut[cnum].b=color[2];
			WritePalette(lut); 
			color_scale();
			tcursor_val(0,ix,iy,7,Buffer,White,White,White);
		}
		if(ans=='t')
		{
			paint_box(0,D_Grey,Buffer,0,y2+37,ScreenXs,ScreenYs-y2-20);
			fx=ix;
			fy=iy;
			ftime=fx*FCycle+fy;
			ltime=ftime;
			plot_uv_graph(Name,ltime);
			timeplot=1;
		}
		if(ans=='T')
		{
			paint_box(0,D_Grey,Buffer,0,y2+37,ScreenXs,ScreenYs-y2-20);
			fx=ix;
			fy=iy;
			ftime=fx*FCycle+fy;
			ltime=ftime;
			plot_uv_vector(Name,ltime);
			timeplot=1;
		}
		paint_box(0,D_Grey,Buffer,0,ScreenYs-21,140,20);
		if(timeplot==0&&ix<=xmax&&iy>=cycle+40&&
					iy<=ymax+cycle+40&&cnum>0&&cnum<240)
		{
			fx=ix;
			fy=iy-cycle-40;
			get_time(fx,fy,ljday0,yr0,&yr,&mo,&da,&hr,&min,&sec);
			sprintf(string,"%2d %s %2d %02d:%02d:%02d",yr,Month[mo],da,hr,min,sec);
			plot_font_h(L_Grey,3,ScreenYs-19,string,2,Font);
		}
		else if(ix<=xmax&&iy<=ymax&&cnum>0&&cnum<240)
		{
			fx=ix;
			fy=iy-cycle-40;
			get_time(fx,fy,ljday0,yr0,&yr,&mo,&da,&hr,&min,&sec);
			sprintf(string,"%2d %s %2d %02d:%02d:%02d",yr,Month[mo],da,hr,min,sec);
			plot_font_h(L_Grey,3,ScreenYs-19,string,2,Font);
		}
	}while(ans!=27);
	*y=iy;
	*x=ix;
	*spd=speed;
	return((int)ans);
}


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

int plot_temp_key(xc,yc,tmin,tmax)

int xc,yc;
float tmin,tmax;

{
	int i,j,k;
	int xs=55,ys=140;
	int val,ival,rval;
	double x,y;
	int ix,iy,it1,it2;
	float temp,delt=tmax-tmin;
	char string[100];

	paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
	it1=tmin;
	it2=tmax;
	plot_font_h(White,xc+2,yc+2,Hdr.Data[1].units,2,Font);
	for(i=it1;i<=it2;i++)
	{
		temp=i;
		j=(tmax-temp)/delt*96;
		k=Black;
		if(i%5==0)
			k=M_Grey;
		if(i%10==0)
			k=White;
		if(k!=Black)
		{
			sprintf(string,"%2d",i);
			plot_font_h(White,xc+2,yc+12+j,string,2,Font);
		}
		plotln(3,xc+20,yc+15+j,xc+xs-6,yc+15+j,k);
	}
	for(i=0;i<96;i++)
	{
		val=i;
		ival=val/8;
		rval=val%8;
		val=ival*15+14-rval;
		plotln(3,xc+30,yc+15+i,xc+40,yc+15+i,val);
	}
	for(i=0;i<5;i++)
		plotln(3,xc+30,yc+111+i,xc+40,yc+111+i,val);
	for(i=0;i<20;i++)
	{
		y=8-i;
		x=100-y*y;
		if(x>0.0)
		{
			x=sqrt(x);
			ix=x;
			plotln(3,xc+35-ix,yc+116+i,xc+35+ix,yc+116+i,val);
		}
	}
}



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

int get_time(fx,fy,ljday0,yr0,yr,mo,da,hr,min,sec)

float fx,fy;
long ljday0;
int yr0;
int *yr,*mo,*da,*hr,*min,*sec;

{
	float ftime;
	long ltime,ljday;
	int jday,yday;

	ftime=(fx*FCycle+fy)*Hdr.sampling_interval;
	ltime=ftime;
	ljday=ljday0+ltime;
	*hr=ljday/3600;
	*hr%=24;
	*min=ljday%3600;
	*min/=60;
	*sec=ljday%60;
	jday=ljday/86400;
	*yr=yr0;
	while((yday=month_day(*yr+1900,jday,mo,da))>0)
	{
		*yr+=1;
		jday-=yday;
	}
}

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

int plot_uv_graph(name,ltime)

char *name;
long ltime;

{
	int i,j,k;
	int iu,iv,id,is,ix,iy,it,speed=16;
	int yv,yu,yvo,yuo,ys,yso;
	FILE *fpin;
	int cycle,val,mo,moo,ival,rval,da,dao,imax,imin;
	float maxspd=70.0,spd,dir,fcycle,fj;
	float tmax,tmin,temp,delt,s,u,v,delu,delv,umax,umin,vmax,vmin,max,min,del;
	double du,dv;
	char string[100];
	int iyd,iy1;
	long offset;

	offset=sizeof(struct time)+sizeof(float)*(Hdr.num_var-1);
	offset*=ltime;
	strcpy(Name,name);
	fpin=p_open(name,"rb");
	if(fpin)
	{	
		fread((char *)&Hdr,sizeof(struct header),1,fpin);
		iu=Hdr.Data[6].order-2;
		iv=Hdr.Data[7].order-2;
		id=Hdr.Data[10].order-2;
		is=Hdr.Data[11].order-2;
		it=Hdr.Data[ 1].order-2;
		if(id<0||is<0)
			return(-1);
		maxspd=Hdr.Data[11].max;
		tmin=Hdr.Data[1].min;
		tmax=Hdr.Data[1].max;
		umax=Hdr.Data[6].max;
		umin=Hdr.Data[6].min;
		vmax=Hdr.Data[7].max;
		vmin=Hdr.Data[7].min;
		max=umax;
		if(max<vmax)max=vmax;
		min=umin;
		if(min>vmin)min=vmin;
		if(max<-min)max=-min;
		if(min>-max)min=-max;
		if(Hdr.Data[is].max>max)
		{
			max=Hdr.Data[is].max;
			min=-max;
		}
		delu=umax-umin;
		delt=tmax-tmin;
		del=max-min;
		imax=max;
		imin=-imax;
		if(delt<=0.0)
			it=-1;
		cycle=FCycle;
		iyd=(ScreenYs-cycle-40)/2;
		iy1=cycle+40+iyd;
		for(i=imin;i<=imax;i++)
		{
			if(i%5==0)
			{
				v=i;
				v=(max-v)/del*2;
				v*=iyd;
				j=v+iy1-iyd;
				k=D_Grey-1;
				if(i%10==0)
					k=D_Grey+1;
				if(i==0)
					k=L_Grey;
				if(k==D_Grey-1)
					plotln(0,0,j,ScreenXs,j,k);
				else
				{
					sprintf(string,"%3d",i);
					plot_font_h(L_Grey,2,j-5,string,2,Font);
					plot_font_h(L_Grey,ScreenXs-23,j-5,string,2,Font);
					plotln(0,25,j,ScreenXs-25,j,k);
				}
			}
		}
		sprintf(string,"U  (east) [%s]",Hdr.Data[6].units);
		plot_font_h(Yellow,25,iy1-iyd,string,2,Font);
		sprintf(string,"V (north) [%s]",Hdr.Data[7].units);
		plot_font_h(Red,25,iy1-iyd+20,string,2,Font);
		sprintf(string,"Speed     [%s]",Hdr.Data[6].units);
		plot_font_h(Blue,25,iy1-iyd+40,string,2,Font);
		da=dao=-1;
		fseek(fpin,offset,SEEK_CUR);
		i=0;
		while(fread((char *)&Data.vtime,sizeof(struct time),1,fpin)>0&&i<ScreenXs)
		{
			da=Data.vtime.da;
			if(da!=dao&&i>0)
				plotln(0,i,cycle+40,i,ScreenYs,L_Grey);
			if(da!=dao&&i>25)
			{
				sprintf(string,"%2d",Data.vtime.da);
				plot_font_h(L_Grey,i+2,ScreenYs-60,string,2,Font);
				sprintf(string,"%s",Month[Data.vtime.mo]);
				plot_font_h(L_Grey,i+2,ScreenYs-40,string,2,Font);
				sprintf(string,"%2d",Data.vtime.yr);
				plot_font_h(L_Grey,i+2,ScreenYs-20,string,2,Font);
			}
			dao=da;
			fread((char *)Data.data,sizeof(float),Hdr.num_var-1,fpin);
			du=u=Data.data[iu];
			u=(max-u)/del*2;
			u*=iyd;
			yu=u+iy1-iyd;
			dv=v=Data.data[iv];
			v=(max-v)/del*2;
			v*=iyd;
			yv=v+iy1-iyd;
			s=sqrt(dv*dv+du*du);
			s=(max-s)/del*2;
			s*=iyd;
			ys=s+iy1-iyd;
			if(i>0)
			{
				plotln(0,i-1,yso,i,ys,Blue);
				plotln(0,i-1,yuo,i,yu,Yellow);
				plotln(0,i-1,yvo,i,yv,Red);
			}
			yuo=yu;
			yvo=yv;
			yso=ys;
/*
			if(it>=0)
			{
				temp=Data.data[it];
				temp=(tmax-temp)/delt*96;
				val=temp;
				ival=val/8;
				rval=val%8;
				val=ival*15+14-rval;
				plotpt(0,i,j+cycle+40,val);
			}
*/
			i+=1;
		}
		fclose(fpin);
	}
}


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

int plot_uv_vector(name,ltime)

char *name;
long ltime;

{
	int i,j,k;
	int iu,iv,id,is,ix,iy,it,speed=16;
	int yv,yu,yvo,yuo,ys,yso,y0;
	FILE *fpin;
	int cycle,val,mo,moo,ival,rval,da,dao,imax,imin;
	float maxspd=70.0,spd,dir,fcycle,fj;
	float tmax,tmin,temp,delt,s,u,v,delu,delv,umax,umin,vmax,vmin,max,min,del;
	double du,dv;
	char string[100];
	int iyd,iy1;
	long offset;

	offset=sizeof(struct time)+sizeof(float)*(Hdr.num_var-1);
	offset*=ltime;
	strcpy(Name,name);
	fpin=p_open(name,"rb");
	if(fpin)
	{	
		fread((char *)&Hdr,sizeof(struct header),1,fpin);
		iu=Hdr.Data[6].order-2;
		iv=Hdr.Data[7].order-2;
		id=Hdr.Data[10].order-2;
		is=Hdr.Data[11].order-2;
		it=Hdr.Data[ 1].order-2;
		if(id<0||is<0)
			return(-1);
		maxspd=Hdr.Data[11].max;
		tmin=Hdr.Data[1].min;
		tmax=Hdr.Data[1].max;
		umax=Hdr.Data[6].max;
		umin=Hdr.Data[6].min;
		vmax=Hdr.Data[7].max;
		vmin=Hdr.Data[7].min;
		max=umax;
		if(max<vmax)max=vmax;
		min=umin;
		if(min>vmin)min=vmin;
		if(max<-min)max=-min;
		if(min>-max)min=-max;
		if(Hdr.Data[is].max>max)
		{
			max=Hdr.Data[is].max;
			min=-max;
		}
		delu=umax-umin;
		delt=tmax-tmin;
		del=max-min;
		imax=max;
		imin=-imax;
		if(delt<=0.0)
			it=-1;
		cycle=FCycle;
		iyd=(ScreenYs-cycle-40)/2;
		iy1=cycle+40+iyd;
		for(i=imin;i<=imax;i++)
		{
			if(i%5==0)
			{
				v=i;
				v=(max-v)/del*2;
				v*=iyd;
				j=v+iy1-iyd;
				k=D_Grey-1;
				if(i%10==0)
					k=D_Grey+1;
				if(i==0)
				{
					k=White;
					y0=j;
				}
				if(k==D_Grey-1)
					plotln(0,0,j,ScreenXs,j,k);
				else
				{
					sprintf(string,"%3d",i);
					plot_font_h(L_Grey,2,j-5,string,2,Font);
					plot_font_h(L_Grey,ScreenXs-23,j-5,string,2,Font);
					plotln(0,25,j,ScreenXs-25,j,k);
				}
			}
		}
		da=dao=-1;
		fseek(fpin,offset,SEEK_CUR);
		i=0;
		while(fread((char *)&Data.vtime,sizeof(struct time),1,fpin)>0&&i<ScreenXs)
		{
			da=Data.vtime.da;
			if(da!=dao&&i>0)
				plotln(0,i,cycle+40,i,ScreenYs,L_Grey);
			if(da!=dao&&i>25)
			{
				sprintf(string,"%2d",Data.vtime.da);
				plot_font_h(L_Grey,i+2,ScreenYs-60,string,2,Font);
				sprintf(string,"%s",Month[Data.vtime.mo]);
				plot_font_h(L_Grey,i+2,ScreenYs-40,string,2,Font);
				sprintf(string,"%2d",Data.vtime.yr);
				plot_font_h(L_Grey,i+2,ScreenYs-20,string,2,Font);
			}
			dao=da;
			fread((char *)Data.data,sizeof(float),Hdr.num_var-1,fpin);
			u=Data.data[iu];
			u=u/del*2;
			u*=iyd;
			yu=u;
			v=Data.data[iv];
			v=v/del*2;
			v*=iyd;
			yv=v;
/*
			spd=Data.data[is];
			spd=spd/maxspd*15.0;
			if(spd>15.0)spd=15.0;
			dir=Data.data[id];
			val=(dir+11.25)/22.5;
			if(val>15)val=0;
			val*=15;
			val+=spd+1;
*/
			temp=Data.data[it];
			temp=(tmax-temp)/delt*96;
			val=temp;
			ival=val/8;
			rval=val%8;
			val=ival*15+14-rval;

			plotln(0,i,y0,i+yu,y0-yv,val);
			yuo=yu;
			yvo=yv;
			yso=ys;
			i+=1;
		}
		fclose(fpin);
	}
	plot_temp_key(ScreenXs-55,0,tmin,tmax);
}



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

int color_scale()

{
	int num=0,speed=16;
	char string[100],ans1,ans2;
	int zxc=0,zyc=0,zxs,zys;

	do
	{
		num=do_menu_buff(menu_c,MENU_C,MENUXC,25,num,D_Grey,L_Grey,White,Font);
		if(num==0)
		{
			do
			{
				ans1=getch();
				if(ans1==0)
				{
					ans2=getch();
					if(ans2==73)
						H1+=1;
					if(ans2==81)
						H1-=1;
					if(ans2==71)
						I1+=speed;
					if(ans2==79)
						I1-=speed;
					if(ans2==72)
						I2+=speed;
					if(ans2==80)
						I2-=speed;
					set_lut('D');
				}
				if(ans1=='+'&&speed<128)
					speed*=2;
				if(ans1=='-'&&speed>1)
					speed/=2;
			}while(ans1!=27&&ans1!=13&&ans2!=83);
		}
		if(num==1)
		{
			I1=0;
			I2=255;
			S1=255;
			S2=255;
			H1=0;
			set_lut('D');
		}
	}while(num<MENU_C-1&&ans1!=27);
}

/********************************************************************
**
**     options:
**
**       -1 -- remove menu but get no answer
**        0 -- return answer and set menu colors to GREYs
**        1 -- return answer but leave colors alone
**
********************************************************************* */

int do_menu_buff(menu,num,xc,yc,start,back,words,boxs,font)

char *menu[];
int num,xc,yc,start,back,words,boxs;
int font[128][25];

{
	int i,j,k;
	char ans,ans2;
	int len=0,l,size=2,val,valo;
	int black=Black,dGREY=D_Grey,lGREY=L_Grey,white=White;
	int wide;

	for(k=0;k<num;k++)
		if((l=strlen(menu[k]))>len)len=l;
	if(len==0)return(-1);
	wide=(len+1)*15/size+1;
	if((639-wide)<xc)xc=639-wide;

	if((xc+(len+1)*15/size+1)<640)
	{
		save_sub_mem(xc,yc,(len+1)*15/size+1,30/size*num+1);
		paint_box(0,dGREY,Buffer,xc,yc,(len+1)*15/size+1,30/size*num+1);
		
		for(k=0;k<num;k++)
		{	
			box(0,xc,yc+k*(30/size),dGREY,(len+1)*15/size,30/size);
			plot_font_h(lGREY,xc+15/size,yc+k*30/size+5/size,menu[k],size,font);
		}
		box(0,xc,yc,lGREY,(len+1)*15/size,30/size*num);
		val=valo=start;
		box(0,xc,yc+val*(30/size),white,(len+1)*15/size,30/size);
		do
		{
			if((ans=getch())==0)
			{
				ans2=getch();
				if(ans2==50)
				{
					recall_sub_mem(xc,yc,(len+1)*15/size+1,30/size*num+1);

					getch();
					paint_box(0,dGREY,Buffer,
						xc,yc,(len+1)*15/size+1,30/size*num+1);
					for(k=0;k<num;k++)
					{	
						plot_font_h(lGREY,xc+15/size,
									yc+k*30/size+5/size,menu[k],size,font);
					}
				}
				if(ans2=='H')
				{
					if(val>0)val-=1;
					else val=num-1;
				}
				if(ans2=='P')
				{
					if(val<num-1)val+=1;
					else val=0;
				}
			}

			for(i=0;i<num;i++)
				if(ans==menu[i][0])
				{
					val=i;
					ans=13;
				}

			box(0,xc,yc+valo*(30/size),dGREY,(len+1)*15/size,30/size);
			valo=val;
			box(0,xc,yc,lGREY,(len+1)*15/size,30/size*num);
			box(0,xc,yc+val*(30/size),white,(len+1)*15/size,30/size);
		}while(ans!=13);
	}
	box(0,xc,yc,dGREY,(len+1)*15/size,30/size*num);
	box(0,xc,yc+val*(30/size),lGREY,(len+1)*15/size,30/size);

	recall_sub_mem(xc,yc,(len+1)*15/size+1,30/size*num+1);
	return(val);
}

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

int save_sub_mem(xc,yc,xs,ys)

int xc,yc,xs,ys;

{
	int i,j,k;

	for(i=0;i<ys;i++)
		getrow(3,xc,xc+xs-1,i+yc,Mbuff+xs*i);
}

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

int recall_sub_mem(xc,yc,xs,ys)

int xc,yc,xs,ys;

{
	int i,j,k;

	for(i=0;i<ys;i++)
		plotrow(3,xc,xc+xs-1,i+yc,Mbuff+xs*i);
}



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

int scan_velocity(x1,x2,y1,y2)

int x1,x2,y1,y2;

{
	int i,j,k;
	int ix,iy;
	int color[3],cnum;
	int eof=0,ixo=x1,iyo=y1;
	int xc=x1,yc=y1,xs=x2-x1+1,ys=y2-y1+1,speed=16;
	long li,delay=4096;
	char ans;

	limit_area_all(&xc,&yc,&xs,&ys,&speed,ScreenXs,ScreenYs,1,Buffer,
		White,White,Black);
	x1=xc;
	y1=yc;
	x2=xs+x1-1;
	y2=ys+y1-1;
	tcursor_val(0,x1,y1,7,Buffer,White,White,White);
	cnum=getpt(0,x1,y1);
	color[0]=lut[cnum].r;color[1]=lut[cnum].g;color[2]=lut[cnum].b;
	lut[cnum].r=lut[cnum].g=lut[cnum].b=White;
	ixo=x1;iyo=y1;
	WritePalette(lut); 
	for(;;)
	{
		for(ix=x1;ix<=x2;ix++)
		{
			for(iy=y1;iy<=y2;iy++)
			{
				if(cnum>0&&cnum<241)
				{
					lut[cnum].r=color[0];lut[cnum].g=color[1];lut[cnum].b=color[2];
					WritePalette(lut); 
				}
				uncursor(0,ixo,iyo,7,Buffer);
				ixo=ix;iyo=iy;
				cnum=getpt(0,ix,iy);
				tcursor_val(0,ix,iy,7,Buffer,White,White,Black);
				if(cnum>0&&cnum<241)
				{
					color[0]=lut[cnum].r;color[1]=lut[cnum].g;color[2]=lut[cnum].b;
					lut[cnum].r=lut[cnum].g=lut[cnum].b=White;
					WritePalette(lut); 
					for(li=0;li<delay;li++);
				}
				if(kbhit()>0)
				{
					ans=getch();
					if(ans==27)
					{
					 	lut[cnum].r=color[0];
						lut[cnum].g=color[1];
						lut[cnum].b=color[2];
						WritePalette(lut); 
						uncursor(0,ixo,iyo,7,Buffer);
						return(0);
					}
					if(ans=='f'&&delay>1)
						delay/=2;
					if(ans=='s')
						delay*=2;
				}
			}
		}
	}
	uncursor(0,ixo,iyo,7,Buffer);
}


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

int chose_files()

{
	int i,j,k;
	int numfile=0;
	char ans;

	printf("      a -- all files\n");
	printf("      8 -- files with 8 reports/hour\n");
	printf("      1 -- files with 1 report/hour\n");
	printf("      v -- by variables present\n");
	ans=getch();
	if(ans=='a')
	{
		numfile=load_File("*.cur");
		for(i=0;i<numfile;i++)
					Chosen[i]=1;
	}
	if(ans=='8')
	{
		numfile=load_File("a*.cur");
		for(i=0;i<numfile;i++)
			Chosen[i]=1;
	}
	if(ans=='1')
	{
		numfile=load_File("h*.cur");
		for(i=0;i<numfile;i++)
			Chosen[i]=1;
	}
	if(ans=='v')
	{
		print_names();
	}
	return(numfile);
}



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

int print_names()

{
	int i,j,k;
	int count=NUMDAT/4;

	for(i=0;i<count;i++)
	{
		if(DType[i].num_name>0)
			printf("%2d -- %s  ",i+1,DType[i].name[1]);
		else
			printf("                    ");
		if(DType[i+count].num_name>0)
			printf("%2d -- %s  ",i+1+count*1,DType[i+count*1].name[1]);
		else
			printf("                    ");
		if(DType[i+count*2].num_name>0)
			printf("%2d -- %s  ",i+1+count*2,DType[i+count*2].name[1]);
		else
			printf("                    ");
		if(DType[i+count*3].num_name>0)
			printf("%2d -- %s  ",i+1+count*3,DType[i+count*3].name[1]);
		else
			printf("                    ");
	}
}



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

int print_chosen(numfile)

int numfile;

{
	int i,j,k;
	char string[100];
	FILE *fpin;
	float i_depth;

	printf("                        Depth   Samp.\n");
	printf("                                 int.\n");
	printf("Stn    Start    Stop   Wtr Inst  min          Data Types\n\n");
	for(i=0;i<numfile;i++)
	{
		if(Chosen[i]==1)
		{
			sscanf(GF_String[i],"%s",string);
			strcat(string,".cur");
			fpin=p_open(string,"rb");
			if(!fpin)
			{
				printf("Could not open '%s'\n",string);
				exit(0);
			}
			fread((char *)&Hdr,sizeof(struct header),1,fpin);
			for(k=1;k<4;k++)
				printf("%c",GF_String[i][k]);
			printf(" %c ",GF_String[i][4]);
			printf("%2d%s%2d ",
				Hdr.start_time.da,Month[Hdr.start_time.mo],
				Hdr.start_time.yr);
			printf("%2d%s%2d ",
				Hdr.stop_time.da,Month[Hdr.stop_time.mo],
				Hdr.stop_time.yr);
			printf("%4.0f ",Hdr.water_depth);
			i_depth=-1.0;
			for(k=0;k<30;k++)
				if(Hdr.Data[k].order!=-1&&Hdr.Data[k].depth>i_depth)
					i_depth=Hdr.Data[k].depth;
			printf("%4.0f ",i_depth);
			printf("%4.1f ",Hdr.sampling_interval/60.0);
			for(k=0;k<NUMDAT;k++)
			{
				if(DType[k].num_name<=0)break;
				if(Hdr.Data[k].order!=-1)
					printf("%c",DType[k].name[0][0]);
				else
					printf(".");
				if((k+1)%10==0)
					printf(" ");
			}
			printf("\n");
			fclose(fpin);					
		}
	}
}


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

int reform_txt()

{
	int i,j,k;
	char string[100],cr=CR;
	int numfile,lastchar,numread;

	numfile=get_file_name("*.txt",string,0);
	if(numfile>=0)
	{
		strcpy(Name,string);
		for(k=0;k<strlen(Name);k++)
			if(Name[k]=='.')
				Name[k]='\0';
		FpIn=p_open(string,"rb");
		if(!FpIn)
		{
			printf("Could not open '%s'\n\n",string);
			return(-1);
		}
	}
	else
		return(-2);
	strcpy(string,Name);
	strcat(string,".cur");
	FpOut=p_open(string,"wb");
	load_hdr(Name,1);
	print_header(Hdr);
	fwrite((char *)&Hdr,sizeof(struct header),1,FpOut);
	fread((char *)Text,sizeof(char),260,FpIn);
	fread((char *)Text,sizeof(char),260,FpIn);
	while(fread((char *)Text,sizeof(char),260,FpIn)==260)
	{
		sscanf(Text+01,"%d",&Data.vtime.yr);
		j=0;
		for(k=4;k<8;k++)
			if(Text[k]!=' '&&Text[k]!='-')
				string[j++]=Text[k];
		string[j]='\0';
		if(j>0)
		{
			Data.vtime.mo=roman(string);
			sscanf(Text+9,"%d",&Data.vtime.da);
			sscanf(Text+13,"%d",&Data.vtime.hr);
			sscanf(Text+16,"%d",&Data.vtime.min);
			sscanf(Text+19,"%d",&Data.vtime.sec);
			for(i=0;i<Hdr.num_var;i++)
				sscanf(Text+22+i*14,"%f",&Data.data[i]);
			printf("%2d %s 19%2d  %02d:%02d:%02d%c",
				Data.vtime.da,Month[Data.vtime.mo],
				Data.vtime.yr,Data.vtime.hr,
				Data.vtime.min,Data.vtime.sec,cr);
			fwrite((char *)&Data.vtime,sizeof(struct time),1,FpOut);
			fwrite((char *)Data.data,sizeof(float),Hdr.num_var-1,FpOut);
		}
	}
	fclose(FpOut);
	fclose(FpIn);
	return(1);
}


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

int load_hdr(name,iop)

char *name;
int iop;

{
	int i,j,k;
	char string1[100],string2[100];
	int numfile,lastchar,numread,eof=0,numstring;
	float deg,min,sec,sign;
	int order=1,trans,cmnt=0;

	Hdr.num_var=0;
	for(k=0;k<NUMDAT;k++)
		Hdr.order[k]=-1;
	for(k=0;k<NUMCOM;k++)
		Hdr.comment[k][0]='\0';
	if(iop!=1)
	{
		strcpy(string1,name);
		strcat(string1,".txt");
		FpIn=p_open(string1,"rb");
		if(!FpIn)
		{
			printf("Could not open '%s'\n\n",string1);
			return(-1);
		}
	}
	for(k=0;k<NUMDAT;k++)
		Hdr.Data[k].order=-1;
	do
	{
		trans=0;
		numread=fread((char *)Text,sizeof(char),260,FpIn);
		sscanf(Text,"%s%s",string1,string2);
		if(strcmpi(string1,"output")==0&&strcmpi(string2,"format")==0)
		{
			if(iop!=1)
				fclose(FpIn);
			return(0);
		}
		lastchar=0;
		for(i=0;i<260;i++)
			if(Text[i]>32&&Text[i]<127)
				lastchar=i;
		numstring=load_string(Text,lastchar);
		Text[lastchar+1]='\0';
		if(strcmpi(String[1],"start")==0&&strcmpi(String[2],"time:")==0)
		{
			trans=1;
			strcpy(Hdr.id,String[0]);
			sscanf(Text+33,"%d",&Hdr.start_time.yr);
			j=0;
			for(k=37;k<41;k++)
				if(Text[k]!=' '&&Text[k]!='-')
					string1[j++]=Text[k];
			string1[j]='\0';
			Hdr.start_time.mo=roman(string1);
			sscanf(Text+42,"%d",&Hdr.start_time.da);
			sscanf(Text+46,"%d",&Hdr.start_time.hr);
			sscanf(Text+49,"%d",&Hdr.start_time.min);
			sscanf(Text+52,"%d",&Hdr.start_time.sec);
			sscanf(Text+64,"%ld",&Hdr.cycles);
		}
		else if(strcmpi(String[0],"stop")==0&&strcmpi(String[1],"time:")==0)
		{
			trans=1;
			sscanf(Text+33,"%d",&Hdr.stop_time.yr);
			j=0;
			for(k=37;k<41;k++)
				if(Text[k]!=' '&&Text[k]!='-')
					string1[j++]=Text[k];
			string1[j]='\0';
			Hdr.stop_time.mo=roman(string1);
			sscanf(Text+42,"%d",&Hdr.stop_time.da);
			sscanf(Text+46,"%d",&Hdr.stop_time.hr);
			sscanf(Text+49,"%d",&Hdr.stop_time.min);
			sscanf(Text+52,"%d",&Hdr.stop_time.sec);
			sscanf(Text+64,"%ld",&Hdr.num_days);
		}
		else if(strcmpi(String[0],"expt.")==0)
		{
			trans=1;
			strcpy(Hdr.expt,String[1]);
			sscanf(Text+46,"%f",&Hdr.sampling_interval);
			if(strcmpi(String[5],"hours")==0)
				Hdr.sampling_interval*=3600.0;
		}
		else if(strcmpi(String[0],"lat.:")==0)
		{
			trans=1;
			sscanf(Text+ 7,"%f",&deg);
			sscanf(Text+11,"%f",&min);
			sscanf(Text+15,"%f",&sec);
			if(String[3][0]=='S')
				sign=-1.0;
			else
				sign=1.0;
			Hdr.lat=sign*(deg+min/60.0+sec/3600.0);
		}
		else if(strcmpi(String[0],"lon.:")==0)
		{
			trans=1;
			sscanf(Text+ 7,"%f",&deg);
			sscanf(Text+11,"%f",&min);
			sscanf(Text+15,"%f",&sec);
			if(String[3][0]=='W')
				sign=-1.0;
			else
				sign=1.0;
			Hdr.lon=sign*(deg+min/60.0+sec/3600.0);
			for(k=41;k<=lastchar;k++)
				Hdr.date_created[k-41]=Text[k];
			Hdr.date_created[lastchar-40]='\0';
		}
		else if(strcmpi(String[0],"water")==0&&strcmpi(String[1],"depth")==0)
		{
			trans=1;
			sscanf(String[3],"%f",&Hdr.water_depth);
			sscanf(Text+37,"%f",&deg);
			if(String[8][0]=='W'||String[8][0]=='E')
			{
				sscanf(String[7],"%f",&min);
				sscanf(String[7]+3,"%f",&sec);
				if(String[8][0]=='W')
					sign=-1.0;
				else
					sign=1.0;
				Hdr.mag_var=sign*(deg+min/60.0+sec/3600.0);
			}
			else
			{
				if(String[7][0]=='W')
					sign=-1.0;
				else
					sign=1.0;
				Hdr.mag_var=sign*deg;
			}
		}
		else
		{
			for(i=0;i<NUMDAT;i++)
			{
				for(k=0;k<DType[i].num_name;k++)
				{
					if(Text[1]=='*'&&
						strcmpi(String[0],DType[i].name[k])==0&&
						Hdr.Data[i].order<0)
					{
						Hdr.num_var+=1;
						trans=1;
						Hdr.order[order-1]=i;
						fill_line(&Hdr.Data[i],order++);
					}
				}
			}
		}
		if(strcmpi(String[0],"comments:")==0)
			strcpy(Hdr.comment[cmnt++],Text);
		else if(cmnt>0&&cmnt<NUMCOM&&numstring>0)
			strcpy(Hdr.comment[cmnt++],Text);
	}while(eof==0&&numread>0);
	if(iop!=1)
		fclose(FpIn);
	return(1);
}


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

int fill_line(ptr,order)

struct info *ptr;
int order;

{
	char string[100];

	ptr->order=order;
	scan_text(Text,ptr->name , 2,14);
	scan_text(Text,ptr->units,15,27);
	scan_text(Text,ptr->codes,28,33);
	if(scan_text(Text,string,34,41)>0)
		sscanf(Text+36,"%f",&ptr->depth);
	else
		ptr->depth=0.0;
	scan_text(Text,ptr->inst ,43,49);
	if(scan_text(Text,string,51,60)>0)
		sscanf(Text+51,"%f",&ptr->min);
	else
		ptr->min=0.0;
	if(scan_text(Text,string,61,70)>0)
		sscanf(Text+61,"%f",&ptr->max);
	else
		ptr->min=0.0;
}

/**************************************************************************
**
**	reads from 1st char to last between c1 and c2
**
************************************************************************* */

int scan_text(instr,outstr,c1,c2)

char *instr,*outstr;
int c1,c2;

{
	int i,j,k;
	int first=-1,last=-1,len;

	for(i=c1;i<=c2;i++)
	{
		if(instr[i]>32&&instr[i]!='*')
		{
			last=i;
			if(first<0)
				first=i;
		}
	}
	len=last-first+1;
	for(i=0;i<len;i++)
		outstr[i]='\0';

	if(first>=0)
		for(i=first;i<=last;i++)
			outstr[i-first]=instr[i];
	outstr[len]='\0';
	return(len);
}

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

int print_header(hdr)

struct header hdr;

{
	int i,j,k;

	printf("%s",Hdr.id);
	for(k=0;k<15-strlen(Hdr.id);k++)
		printf(" ");
	printf("start time = %2d %s 19%2d  %02d:%02d:%02d",
		Hdr.start_time.da,Month[Hdr.start_time.mo],
		Hdr.start_time.yr,Hdr.start_time.hr,
		Hdr.start_time.min,Hdr.start_time.sec);
	printf("  cycles = %ld\n",Hdr.cycles);
	printf("               stop  time = %2d %s 19%2d  %02d:%02d:%02d",
		Hdr.stop_time.da,Month[Hdr.stop_time.mo],
		Hdr.stop_time.yr,Hdr.stop_time.hr,
		Hdr.stop_time.min,Hdr.stop_time.sec);
	printf("  # days = %ld\n",Hdr.num_days);
	printf("Expt. = '%s'  ",Hdr.expt);
	printf("sampling interval = %0.2f minutes\n",
		Hdr.sampling_interval/60.0);
	printf("Lat = %10.6f\n",Hdr.lat);
	printf("Lon = %10.6f  File created: %s\n",
		Hdr.lon,Hdr.date_created);
	printf("depth = %0.0fm  Mag.var = %10.6f\n",
		Hdr.water_depth,Hdr.mag_var);
	printf(
"#  Variable     Units        Codes Depth   Inst.   Minimum   Maximum\n");
printf(
"-- ------------ ------------ ----- ------- ------ --------- ---------\n");
	for(j=0;j<Hdr.num_var;j++)
	{
		i=Hdr.order[j];

		printf("%2d ",Hdr.Data[i].order);
		printf("%s",Hdr.Data[i].name);
		if(strlen(Hdr.Data[i].name)<13)
			for(k=0;k<13-strlen(Hdr.Data[i].name);k++)
				printf(" ");
		printf("%s",Hdr.Data[i].units);
		if(strlen(Hdr.Data[i].units)<13)
			for(k=0;k<13-strlen(Hdr.Data[i].units);k++)
				printf(" ");
		printf("%s",Hdr.Data[i].codes);
		if(strlen(Hdr.Data[i].codes)<6)
			for(k=0;k<6-strlen(Hdr.Data[i].codes);k++)
				printf(" ");
		if(Hdr.Data[i].depth!=0.0||
				Hdr.Data[i].min!=0.0||
				Hdr.Data[i].max!=0.0||
				strlen(Hdr.Data[i].inst)>0)
		{
			printf("%7.2f ",Hdr.Data[i].depth);
			printf("%s",Hdr.Data[i].inst);
			if(strlen(Hdr.Data[i].inst)<6)
				for(k=0;k<6-strlen(Hdr.Data[i].inst);k++)
					printf(" ");
			printf("%10.3f",Hdr.Data[i].min);
			printf("%10.3f\n",Hdr.Data[i].max);
		}
		else
			printf("\n");
	}
printf(
"---------------------------------------------------------------------\n");
	for(k=0;k<NUMCOM;k++)
		if(strlen(Hdr.comment[k])>0)
			printf("%s\n",Hdr.comment[k]);
}

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

int roman(string)

char *string;

{
	int val=-1;

	if(strcmpi(string,"I")==0)
		val=1;
	else if(strcmpi(string,"II")==0)
		val=2;
	else if(strcmpi(string,"III")==0)
		val=3;
	else if(strcmpi(string,"IV")==0)
		val=4;
	else if(strcmpi(string,"V")==0)
		val=5;
	else if(strcmpi(string,"VI")==0)
		val=6;
	else if(strcmpi(string,"VII")==0)
		val=7;
	else if(strcmpi(string,"VIII")==0)
		val=8;
	else if(strcmpi(string,"IX")==0)
		val=9;
	else if(strcmpi(string,"X")==0)
		val=10;
	else if(strcmpi(string,"XI")==0)
		val=11;
	else if(strcmpi(string,"XII")==0)
		val=12;

	if(val<0)
		printf("Could not translate '%s'\n",string);

	return(val);
}


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

int load_string(text,last)

char *text;
int last;

{
	int i=0,j=0,k;
	int numstr=-1,inword=0;

	if(last<1)
		return(0);
	do
	{	
		if(char_type(text[i])>0&&text[i]!='*')
		{
			if(inword==0)
				numstr+=1;
			String[numstr][j++]=text[i];
			inword=1;
		}
		if(char_type(text[i])<1)
		{
			if(inword==1)
				String[numstr][j]='\0';
			j=0;
			inword=0;
		}
		i+=1;
		if(j>0)
			String[numstr][j]='\0';
	}while(i<=last);
	return(numstr+1);
}


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

int char_type(cval)

char cval;

{
	if(cval==9||cval==10||cval==12||cval==13||cval==32)
		return(0);
	if(cval>=33&&cval<=126)
		return(1);
	return(-1);
}



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

int print_hdr()

{
	int i,j,k;
	char string1[100],string2[100];
	int numfile,lastchar;

	numfile=get_file_name("*.txt",string1,0);
	if(numfile>=0)
	{
		strcpy(Name,string1);
		for(k=0;k<strlen(Name);k++)
			if(Name[k]=='.')
				Name[k]='\0';
		FpIn=p_open(string1,"rb");
		if(!FpIn)
		{
			printf("Could not open '%s'\n\n",string1);
			return(-1);
		}
	}
	else
		return(-2);
	while(fread((char *)Text,sizeof(char),260,FpIn)==260)
	{
		sscanf(Text,"%s%s",string1,string2);
		if(strcmpi(string1,"output")==0&&strcmpi(string2,"format")==0)
		{
			for(i=0;i<6;i++)
			{
				fread((char *)Text,sizeof(char),260,FpIn);
				Text[75]='\0';
				printf("%d '%s'\n",i+1,Text);
			}
			fclose(FpIn);
			return(0);
		}
		lastchar=0;
		for(i=0;i<260;i++)
			if(Text[i]!=0x20)
				lastchar=i;
		if(lastchar<80)
			lastchar=80;
		for(i=0;i<lastchar;i++)
			printf("%c",Text[i]);
	}
	fclose(FpIn);
	return(1);
}

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

int set_video_on()

{
	int i,row;

	i=GetVideoBoardID();
#ifdef NUMBER9
	VideoType='X';
	B_Id.row=1024;
	B_Id.col=1024;
	ScreenXs=1024;
	ScreenYs=1024;
	strcpy(Suffix,".nmp");
	FontSize=1;
#else
	if(VideoType=='X')
	{
		row=SetVideoMode(480,&B_Id);
		if(B_Id.row<400)
			VideoType='V';
		else
		{
			ScreenXs=640;
			ScreenYs=row;
			Num_Color=256;
		}
	}
	if(VideoType=='Y')
	{
		row=SetVideoMode(400,&B_Id);
		if(B_Id.row<400)
			VideoType='V';
		else
		{
			ScreenXs=640;
			ScreenYs=row;
		}
		Num_Color=256;
	}
	if(VideoType=='V')
	{
		row=SetVideoMode(0x12,&B_Id);
		if(B_Id.row!=480)
			VideoType='E';
		else
		{
			ScreenXs=640;
			ScreenYs=480;
			Num_Color=16;
		}
	}
	if(VideoType=='S')
	{
		row=SetVideoMode(0x13,&B_Id);
		if(B_Id.row!=200)
		{
			SetVideoMode(0,&B_Id);
			printf("Could not boot color board.\n");
			exit(0);
		}
		ScreenXs=320;
		ScreenYs=200;
		Num_Color=256;
	}
	if(VideoType=='E')
	{
		row=SetVideoMode(0x10,&B_Id);
		if(B_Id.row!=350)
		{
			SetVideoMode(0,&B_Id);
			printf("Could not boot color board.\n");
			exit(0);
		}
		ScreenXs=640;
		ScreenYs=350;
		Num_Color=16;
	}
	if(B_Id.row<0)
	{
		SetVideoMode(0,&B_Id);
		printf("Could not boot board -- row = %d\n\n",row);
		exit(0);
	}
#endif
	ScreenXs=B_Id.col;
	ScreenYs=B_Id.row;
}


/********************************************************************
**
**	type  g -- grey all lut[] files
**			G -- grey only lut[]
**			i -- initial header map
**			r -- reset lut[] to lutc[]
**			p -- positive (0-127) magenta, negative (128-255) green
**
********************************************************************* */

int set_lut(type,filename)

char type,*filename;

{
	int i,k,hue,brite,j;
	float color[3];
	double dbrite,dval;
	float val,minval,sat,inten;
	char string[100];
	int r,g,b,sum;
	float fval,fk,fj,fint,dint=I2-I1;
	FILE *fplut;

	if(type=='D')
	{
		for(i=0;i<16;i++)
		{
			for(j=0;j<15;j++)
			{
				hue=i+H1;
				while(hue>15)hue-=16;
				while(hue<0)hue+=16;
				k=i*15+j+1;
				if(hue==0&&j==14)
					Red=k;
				if(hue==2&&j==14)
					Orange=k;
				if(hue==4&&j==14)
					Yellow=k;
				if(hue==8&&j==14)
					Green=k;
				if(hue==9&&j==14)
					Cyan=k;
				if(hue==11&&j==14)
					Blue=k;
				if(hue==15&&j==14)
					Magenta=k;
				fj=j;
				fj/=14;
				fint=I2-I1;
				fint*=fj;
				fint+=I1;
				fint/=256;
				while(fint>1.0)fint-=1.0;
				while(fint<0.0)fint+=1.0;
				fval=DirHues[hue][0];
				fval*=fint;
				lut[k].r=fval;
				fval=DirHues[hue][1];
				fval*=fint;
				lut[k].g=fval;
				fval=DirHues[hue][2];
				fval*=fint;
				lut[k].b=fval;
			}
		}
		for(i=1;i<16;i++)
		{
			lut[240+i].r=Color_Val[i][0];
			lut[240+i].g=Color_Val[i][1];
			lut[240+i].b=Color_Val[i][2];
		}
		lut[0].r=lut[0].g=lut[0].b=0;
		Black=BLACK;
		D_Grey=D_GREY;
		M_Grey=M_GREY;
		L_Grey=L_GREY;
		White=WHITE;
	}
	if(type=='P')
	{
		fplut=p_open(filename,"rt");
		if(fplut)
		{
			i=0;
			do
			{
				i+=1;
				fscanf(fplut,"%s",string);
			}while(strcmpi(string,"end")!=0&&i<50);
			if(strcmpi(string,"end")!=0)
				rewind(fplut);
			for(i=0;i<256;i++)
			{
				fscanf(fplut,"%d%d%d%d",&k,&r,&g,&b);
				lutc[i].r=lut[i].r=r;
				lutc[i].g=lut[i].g=g;
				lutc[i].b=lut[i].b=b;
			}
			fclose(fplut);
			Color_Image=1;
		}
		else
			return(-1);
		if(VideoType!='X')
		{
			for(i=0;i<256;i++)
			{
				sum=lutc[i].r;
				sum+=lutc[i].g;
				sum+=lutc[i].b;
				sum/=48;
				Vga_Color[i]=sum;
			}
			for(k=0;k<16;k++) 
			{ 
				lutc[k].r=lut[k].r=k*17;
				lutc[k].g=lut[k].g=k*17;
				lutc[k].b=lut[k].b=k*17;
			} 
			Black=0;
			D_Grey=4;
			L_Grey=11;
			White=15;
		}
	}
	if(type=='g')
	{
		Color_Lines=0;
		if(Reverse==0)
		{
			if(VideoType=='X')
			{
				for(k=0;k<256;k++) 
				{ 
					lut[k].r=k; 
					lut[k].g=k; 
					lut[k].b=k; 
				} 
				Black=0;
				D_Grey=46;
				L_Grey=191;
				White=255;
			}
			else
			{
				for(k=0;k<16;k++) 
				{ 
					lut[k].r=k*17;
					lut[k].g=k*17; 
					lut[k].b=k*17; 
				} 
				Black=0;
				D_Grey=4;
				L_Grey=11;
				White=15;
			}
		}
		else
		{
			if(VideoType=='X')
			{
				for(k=0;k<256;k++) 
				{ 
					lut[k].r=255-k; 
					lut[k].g=255-k; 
					lut[k].b=255-k; 
				} 
				Black=255;
				D_Grey=209;
				L_Grey=64;
				White=0;
			}
			else
			{
				for(k=0;k<16;k++) 
				{ 
					lut[k].r=255-k*17;
					lut[k].g=255-k*17; 
					lut[k].b=255-k*17; 
				} 
				Black=15;
				D_Grey=12;
				L_Grey=4;
				White=0;
			}
		}
	}
	if(type=='r')
	{
		for(k=1;k<9;k++) 
		{ 
			j=(8-k)*20;
			lut[k].r=MaxHues[j][0];
			lut[k].g=MaxHues[j][1];
			lut[k].b=MaxHues[j][2];
		} 
		lut[0].r=lut[0].g=lut[0].b=46.0;
		for(k=9;k<16;k++) 
		{ 
			j=(k-9)*36;
			lut[k].r=j;
			lut[k].g=j;
			lut[k].b=j;
		} 
		White=15;
		Black=9;
		D_Grey=11;
		L_Grey=13;
	}
	if(type=='d')
	{
		Color_Lines=1;
		if(VideoType=='X')
		{
			for(k=0;k<128;k++)
			{
				lut[k].r=k*2;
				lut[k].g=k*2;
				lut[k].b=k*2;
			}
			Black=0;
			D_Grey=23;
			L_Grey=96;
			White=127;
		}
		else
		{
			for(k=0;k<8;k++)
			{
				lut[k].r=k*2*18;
				lut[k].g=k*2*18;
				lut[k].b=k*2*18;
			}
			Black=0;
			D_Grey=2;
			L_Grey=6;
			White=7;
		}
		for(k=0;k<8;k++)
		{
			lut[k+Num_Color/2].r=Color[k].r;
			lut[k+Num_Color/2].g=Color[k].g;
			lut[k+Num_Color/2].b=Color[k].b;
		}			
	}
	WritePalette(lut); 
}