/*
	segment.c

	sgg.bat = cl /AL segment.c vimage3 graphlib

	R. Ambroziak USGS/OMG

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

#define BLACK  0
#define D_GREY 1
#define L_GREY 2
#define WHITE  3
#define MAX_BLOCK 8000
#define NUM_SEG 32
#define WIDTH 640
#define HEIGHT 480
#define D_SCALE 5
#define W_SCALE 2
#define MAX_SHOTS 5000
#define NUMLINE 8
#define MENU_C 6
#define MENUXC 550
#define LOG10  2.302585093
#define MSK_EXP_IEEE  0x7f800000
#define MSK_SIGN_IEEE 0x80000000
#define SQRT2 1.41421356237
#define S_SIZE 40

struct file_id
{
	char name[S_SIZE];
	long size;
	unsigned date,time;
};
extern struct file_id GF_File[];
extern int GF_Order[];
struct board
{
	int row,col,color;
}B_Id;
int Red,Green,Cyan,Yellow;
int C_Red[3]=    {255,  0,  0};
int C_Green[3]=  {  0,255,  0};
int C_Cyan[3]=   {  0,255,255};
int C_Yellow[3]= {255,255,  0};
int RMS_Mean=1,Power=0;
double MeanRMS;
float Cor,Lo,Hi;
int NumHue=6,Xs=640,Ys=480;
char PlotSufx[10]=".vpt";
char VideoType='X';
float FNumHue=6.0;
float Gain=W_SCALE,Vf,Hf;
int T1,P1;
char *menu_c[MENU_C]= 
	{"intensity","hue","saturation",	"reset","grey scale","exit color"}; 
char Digit[100];
int Map_Xmin,Map_Ymin;
float Map_Scale;
int Shot_X[MAX_SHOTS],Shot_Y[MAX_SHOTS];
int Num_Shots=0;
unsigned char S_Buff[12800],Buff[12][640],ImBuff[20][640];
unsigned char Inbuff1[BUFSIZ],Inbuff2[BUFSIZ],Inbuff3[BUFSIZ],Inbuff4[BUFSIZ];
unsigned char P_Out[WIDTH][4],P_In[HEIGHT][8];
float Data[(MAX_BLOCK-240)/4];
char InFile[100];

int ScreenXs,ScreenYs;
int Map=0,Color=0;
int Cxc,Cyc,Cxs,Cys;
int Pxc,Pyc,Pxs,Pys;
float H1=0.0,H2=155.0,H3=0.0;
float S1=1.0,S2=1.0,S3=1.0;
float I1=0.5,I2=0.5,I3=1.0;
float Iadj=0.5,Sadj=1.0,Hadj=1.0;
double decode_line();
FILE *Fpin,*FpRms,*FpVal,*FpDb,*FpPlot,*FpHdr,*FpSpn;
struct   Color 
{ 
	unsigned char  r, g, b; 
}lut[256],lutm[256],lutc[256],luts[256]; 
struct seismic
{
	int block_size;			/* size of block on seg-y tape */
	int first_trace;			/* number of first trace */
	int num_trace;				/* number of traces in data set */
	float time_line;			/* number of data points per second */
	int first_point;			/* shot point number of first trace */
	int point_space;			/* number of traces per shot point */
	int map_point1;			/* number of first point on map */
	int map_space;				/* distance between points on map */
	double mean_rms;			/* optional -- mean rms to use else compute */
	double power;				/* optional -- power adjust -- default = 1 */
}S;
int FileNum;
int LabelTrace=0;
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
};
unsigned char EBCDIC[256]=
{
	0x00,0x01,0x02,0x03,
	0x00,0x09,0x00,0x7f,
	0x00,0x00,0x00,0x0b,
	0x0c,0x0d,0x0e,0x0f,
	0x10,0x11,0x12,0x00,
	0x00,0x13,0x08,0x00,
	0x18,0x19,0x00,0x00,
	0x1c,0x1d,0x1e,0x1f,
	0x00,0x00,0x1c,0x00,
	0x00,0x0a,0x17,0x1b,
	0x00,0x00,0x00,0x00,
	0x00,0x05,0x06,0x07,
	0x00,0x00,0x16,0x00,
	0x00,0x1e,0x00,0x04,
	0x00,0x00,0x00,0x00,
	0x14,0x15,0x00,0x1a,
	0x20,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x2e,
	0x3c,0x28,0x2b,0x5e,
	0x26,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x00,0x21,0x24,
	0x2a,0x29,0x3b,0x5e,
	0x2d,0x2f,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x00,0x7c,0x2c,
	0x25,0x5f,0x3e,0x3f,
	0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x60,0x3a,0x23,
	0x40,0x27,0x3d,0x22,
	0x00,0x61,0x62,0x63,
	0x64,0x65,0x66,0x67,
	0x68,0x69,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x6a,0x6b,0x6c,
	0x6d,0x6e,0x6f,0x70,
	0x71,0x72,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x7e,0x73,0x74,
	0x75,0x76,0x77,0x78,
	0x79,0x7a,0x00,0x00,
	0x00,0x5b,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x00,0x5d,0x00,0x00,
	0x7b,0x41,0x42,0x43,
	0x44,0x45,0x46,0x47,
	0x48,0x49,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x7d,0x4a,0x4b,0x4c,
	0x4d,0x4e,0x4f,0x50,
	0x51,0x52,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x5c,0x00,0x53,0x54,
	0x55,0x56,0x57,0x58,
	0x59,0x5a,0x00,0x00,
	0x00,0x00,0x00,0x00,
	0x30,0x31,0x32,0x33,
	0x34,0x35,0x36,0x37,
	0x38,0x39,0x00,0x00,
	0x00,0x00,0x00,0x00
};
unsigned char Pbuff[4][NUMLINE][800],Buffer[4096],OutBuff[1024][4];
int TgaHdr[9]={0,2,0,0,0,0,640,480,32};
int CutOff[NUMLINE];
int PixBrite[12][WIDTH];
unsigned char ValA[WIDTH],ValB[WIDTH];
int Pass[256][2];
int MaxPass=0;

unsigned char getpt();
void set_lut();

int plot_scan(char *file);
int load_lbl(void);
void s_box(int hue,int xc,int yc,int val,int xsize,int ysize);
void print_screen(void);
void seismic(int iop);
int limit_area_seg(int *x,int *y,int *xsize,int *ysize,int *speed,
				int maxbox,int iop,unsigned char *buffer);
int set_video_on(void);
void color_scale(int xc,int yc,int xs,int ys);
int do_menu_buff(char *menu[],int num,int xc,int yc,int start,
				int back,int words,int boxs,int font[128][25]);
int save_sub_mem(int xc,int yc,int xs,int ys);
int recall_sub_mem(int xc,int yc,int xs,int ys);
void color_bar(int xc,int yc,int xs,int ys);
int plot_map(int *pxc,int *pyc,int *pxs,int *pys,int iop);
void plot_segment(int xc,int yc,int xs,int ys,float vscale,float hscale,
					int t1,int p1);
int power_data(float *data,int numpts);
double decode_line(int numpts,unsigned char *buff,float *data);
void set_lut(char type);
char limit_area_shape(int *x,int *y,int *xsize,int *ysize,int *speed,
			int maxbox,int iop,unsigned char *buffer);
void label_trace(int xc,int yc,int xs,int ys,float vscale,float hscale,
			int t1,int p1);
int load_pass(char *string,int pass[256][2]);

main(argc,argv)

int argc;
char *argv[];

{
	int i,j,k;
	char string[100],ans,val;
	int numfile;
	FILE *fp;

	if(argc>1)
	{
		for(i=0;i<argc;i++)
		{
			j=i+1;
			Map=0;
			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[j][0]=='/'&&(argv[j][1]=='M'||argv[j][1]=='m'))
				RMS_Mean=1;
			if(argv[j][0]=='/'&&(argv[j][1]=='T'||argv[j][1]=='t'))
				RMS_Mean=0;
			if(argv[j][0]=='/'&&(argv[j][1]=='P'||argv[j][1]=='p'))
			{
				if(argc<j+3)
				{
					printf
("\nWhen using '/p' option you must follow it with LOW and HIGH exponent\n");
					printf
("which is the minimum and maximum power of 2 plus 127:\n");
					printf
("127 represents 2 to the zero or 1.\n\n");
					printf
("Run program 'exphist' on '.val' file or try\n\n     segment /p 120 135\n\n");
					printf
("Possible values for LOW and HIGH are 1 to 255\n\n");
					exit(0);
				}
				Power=1;
				RMS_Mean=1;
				sscanf(argv[j+1],"%f",&Lo);
				sscanf(argv[j+2],"%f",&Hi);
				if(Lo==0.0||Hi==0.0||Lo>=Hi)
				{
					printf
("\nWhen using '/p' option you must follow it with LOW and HIGH exponent\n");
					printf
("which is the minimum and maximum power of 2 plus 127:\n");
					printf
("127 represents 2 to the zero or 1.\n\n");
					printf
("Run program 'exphist' on '.val' file or try\n\n     segment /p 120 135\n\n");
					printf
("Possible values for LOW and HIGH are 1 to 255\n\n");
					exit(0);
				}
				printf("LOW = %f   HIGH = %f\n",Lo,Hi);
			}
		}
	}
	if(VideoType=='X')
	{
		strcpy(PlotSufx,".xpt");
	}
	set_video_on();
	SetVideoMode(0);
	do
	{
		printf("\n\n   v -- view a seismic segment in detail\n");
		printf("   p -- preview all processed seismic segments\n");
		printf("   h -- print EBCIDIC header on screen\n");
		printf("   s -- print side panel on screen\n");
		printf("\n   x -- exit program\n\n");

		ans=getch();

		if(ans=='v')
		{
			numfile=get_file_name("*.val",InFile);
			if(numfile>=0)
			{
				for(k=0;k<strlen(InFile);k++)
				if(InFile[k]=='.')
					InFile[k]='\0';
				if(load_lbl()>0)
					seismic(0);
			}
		}
		if(ans=='V')
		{
			numfile=load_names("*.val");
			sort_name(numfile);
			for(i=0;i<numfile;i++)
			{
				strcpy(InFile,GF_File[GF_Order[i]].name);
				for(k=0;k<strlen(InFile);k++)
				if(InFile[k]=='.')
					InFile[k]='\0';
				printf("Working '%s'\n",InFile);
				if(load_lbl()>0)
					seismic(1);
			}
		}
		if(ans=='p')
		{
			strcpy(string,"*");
			strcat(string,PlotSufx);
			numfile=get_file_name(string,InFile);
			if(numfile>=0)
			{
				for(k=0;k<strlen(InFile);k++)
				if(InFile[k]=='.')
					InFile[k]='\0';
				plot_scan(InFile);
			}
		}
		if(ans=='h')
		{
			numfile=get_file_name("*.hdr",InFile);
			if(numfile>=0)
			{
				FpHdr=fopen(InFile,"rb");
				if(FpHdr)
				{
					fread((char *)S_Buff,sizeof(char),3200,FpHdr);
					for(i=0;i<3200;i++)
					{
						if(i==1600)
							getch();
						printf("%c",EBCDIC[S_Buff[i]]);
					}
					getch();
				}
				if(FpHdr)
					fclose(FpHdr);
			}
		}
		if(ans=='s')
		{
			numfile=get_file_name("*.spn",InFile);
			if(numfile>=0)
			{
				FpSpn=fopen(InFile,"rb");
				if(FpSpn)
				{
					i=0;
					do
					{
						while((val=fgetc(FpSpn))!=0xa&&val!=EOF)
							printf("%c",val);
						if(val!=EOF)
							printf("%c",val);
						i+=1;
						if(i%20==0)
							getch();
					}while(val!=EOF);
					if(i%20!=0)
						getch();
				}
				if(FpHdr)
					fclose(FpHdr);
			}
		}
	}while(ans!='x'&&ans!=27);
}

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

int plot_scan(char *file)

{
	int i,j,k;
	char string[100];
	int row,col;
	int mxc,myc,mxs,mys;
	FILE *fp;

	strcpy(string,file);
	strcat(string,PlotSufx);
	fp=fopen(string,"rb");
	if(!fp)
		return(-1);
	set_video_on();
	if(VideoType=='X')
		set_lut('g');
	set_lut('p');
	fread((char *)&row,sizeof(int),1,fp);
	fread((char *)&col,sizeof(int),1,fp);
	s_box(3,0,0,WHITE,col+1,row+1);
	for(i=0;i<row;i++)
	{
		fread((char *)ImBuff[0],sizeof(char),col,fp);
		plotrow(0,0,col-1,i,ImBuff[0]);
	}
	if(fp)
		fclose(fp);
	plot_map(&mxc,&myc,&mxs,&mys,3);
	plot_font_h(WHITE,5,Ys-26,"Hit any key to continue",2,Font);
	getch();
	SetVideoMode(0);
}


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

int load_lbl(void)

{
	char string[100],instr1[100],instr2[100];
	FILE *fp;

	strcpy(string,InFile);
	strcat(string,".lbl");		
	fp=fopen(string,"rt");

	S.mean_rms=0.0;
	if(fp)
	{

		while(fscanf(fp,"%s%s",instr1,instr2)==2)
		{
			if(strcmpi(instr2,"seg-y_block_size")==0)
			{
				sscanf(instr1,"%d",&S.block_size);
				printf("%40s = %8d\n",instr2,S.block_size);
			}
			if(strcmpi(instr2,"first_trace_number")==0)
			{
				sscanf(instr1,"%d",&S.first_trace);
				printf("%40s = %8d\n",instr2,S.first_trace);
			}
			if(strcmpi(instr2,"number_of_traces")==0)
			{
				sscanf(instr1,"%d",&S.num_trace);
				printf("%40s = %8d\n",instr2,S.num_trace);
			}
			if(strcmpi(instr2,"data_points_per_second")==0)
			{
				sscanf(instr1,"%f",&S.time_line);
				printf("%40s = %8.2f\n",instr2,S.time_line);
			}
			if(strcmpi(instr2,"shot_points_number_of_first_trace")==0)
			{
				sscanf(instr1,"%d",&S.first_point);
				printf("%40s = %8d\n",instr2,S.first_point);
			}
			if(strcmpi(instr2,"traces_per_shot_point")==0)
			{
				sscanf(instr1,"%d",&S.point_space);
				printf("%40s = %8d\n",instr2,S.point_space);
			}
			if(strcmpi(instr2,"number_of_first_point_on_map")==0)
			{
				sscanf(instr1,"%d",&S.map_point1);
				printf("%40s = %8d\n",instr2,S.map_point1);
			}
			if(strcmpi(instr2,"shot_points_per_map_point")==0)
			{
				sscanf(instr1,"%d",&S.map_space);
				printf("%40s = %8d\n",instr2,S.map_space);
			}
			if(strcmpi(instr2,"mean_rms_override")==0)
			{
				sscanf(instr1,"%lf",&S.mean_rms);
				printf("%40s = %8.2lf\n",instr2,S.mean_rms);
			}
		}
		if(fp)
			fclose(fp);
		return(1);
	}
	else
		return(-1);
}

/********************************************************************
**
**	draws a box of brightness 'val' at 'xc,yc' size 'size'
**
**	functions called: 
**		plotpt();
**
**
********************************************************************* */

void s_box(int hue,int xc,int yc,int val,int xsize,int ysize)

{
	int i,j,k,y1,y2,x1,x2;
	
	y1 = yc;
	y2 = yc+ysize;
	x1 = xc;
	x2 = xc+xsize;

	for(i=y1;i<=y2;i++){
		plotpt(hue,x1,i,val);
		plotpt(hue,x2,i,val);
	}
	for(i=x1;i<=x2;i++){
		plotpt(hue,i,y1,val);
		plotpt(hue,i,y2,val);
	}
}




/********************************************************************
**
**	prints screen to Targa file
**
********************************************************************* */

void print_screen(void)

{
	int i,j,k;
	FILE *fpout;
	char string[100],path[100];
	int row=480,col=640,val,len;

	if(VideoType=='E')
		row=350;
	if(VideoType=='Y')
		row=400;
	k=0;
	get_string(path,S_Buff,"Give destination disk and path",
			"e.g. D:\\TEST\\",10,10,210,48,1,1,
			Font,WHITE);
	if((len=path[strlen(path)-1])!='\\')
	{
		path[len]='\\';
		path[len+1]='\0';
	}
	do
	{
		sprintf(string,"%ssegmnt%02d.tga",path,k++);
		fpout=fopen(string,"rb");
	}while(fpout&&k<20);
	if(fpout)
		fclose(fpout);
	fpout=fopen(string,"wb");
	if(!fpout)
		return;
	TgaHdr[6]=col;
	TgaHdr[7]=row;
	fwrite((char *)TgaHdr,sizeof(int),9,fpout);
	for(i=0;i<row;i++)
	{
		getrow(0,0,col-1,row-1-i,Buffer);
		for(j=0;j<col;j++)
		{
			val=Buffer[j];
			OutBuff[j][0]=lut[val].b;
			OutBuff[j][1]=lut[val].g;
			OutBuff[j][2]=lut[val].r;
		}
		fwrite((char *)OutBuff,sizeof(char),col*4,fpout);
	}
	if(fpout)
		fclose(fpout);
}

/**************************************************************************
**
**  iop = 0 normal processing
**  iop = 1 auto processing for 'V' option
**
************************************************************************* */

void seismic(int iop)

{
	int i,j,k;
	int t1,p1;
	float vscale,hscale,ft1,fp1;
	int xc,yc,xs,ys,speed=16;
	int pxc,pyc,pxs,pys,pspeed=16;	/* zoom view box */
	int bxc,byc,bxs,bys,bspeed=16;	/* box on plot */
	int mxc,myc,mxs,mys,mspeed=16;	/* map */
	int txc,tyc,txs=300,tys=15;		/* full plot */
	int cxc=501,cyc=Ys-51,cxs=138,cys=50,cspeed=8;
	int ivscale,ihscale,iscale;
	int numpts=(S.block_size-240)/4;
	int numtrc=S.num_trace;
	float fxs,fbxs,fr;
	char ans,filename[100];
	double num_rms=0.0,rms,rms_rms=0.0;
	
	xc=0;
	yc=0;

	strcpy(filename,InFile);
	strcat(filename,".rms");
	FpRms=fopen(filename,"rb");
	if(!FpRms)
	{
		printf("Could not open file '%s'\n",filename);
		return;
	}
	if(RMS_Mean==1)
	{
		if(S.mean_rms==0.0)
		{
			num_rms=MeanRMS=0.0;
			while(fread((char *)&rms,sizeof(double),1,FpRms)==1)
			{
				if(rms>0.0)
				{
					num_rms+=1.0;
					MeanRMS+=rms;
					rms_rms+=rms*rms;
				}
			}
			if(num_rms>1.0)
			{
				MeanRMS/=num_rms;
				rms_rms/=num_rms;
			}
			rms_rms=sqrt(rms_rms);
			if(FpRms)
				rewind(FpRms);
		}
		else
			MeanRMS=S.mean_rms;
	}
	strcpy(filename,InFile);
	strcat(filename,".val");
	FpVal=fopen(filename,"rb");
	if(!FpVal)
	{
		printf("Could not open file '%s'\n",filename);
		return;
	}
	setbuf(FpVal,Inbuff2);

	ihscale=numtrc/(WIDTH-14)+1;
	ivscale=numpts/Ys+1;

	if(ihscale*D_SCALE>ivscale)
		ivscale=ihscale*D_SCALE;
	else
		ihscale=ivscale/D_SCALE;
	if(numtrc/ihscale>WIDTH/2&&numpts/ivscale>Ys/2)
	{
		ihscale*=2;
		ivscale*=2;
	}
	vscale=ivscale;
	hscale=ihscale;
	xs=numtrc/ihscale+14;
	ys=numpts/ivscale;

	set_video_on();
	if(VideoType=='X')
		set_lut('g');
	set_lut('p');
	cyc=Ys-51;
	paint_box(3,D_GREY,Buff[0],0,0,Xs,Ys);
	txc=xc+5;tyc=yc+5;
	plot_font_h(WHITE,txc,tyc,"Full Seismic Segment",2,Font);
	if(iop==0)
		limit_area_seg(&xc,&yc,&xs,&ys,&speed,WIDTH,0,(unsigned char *)Buff);
	paint_box(3,D_GREY,Buff[0],txc,tyc,txs,tys);
	s_box(3,xc,yc,L_GREY,xs,ys);
	strcpy(filename,InFile);
	strcat(filename,PlotSufx);
	FpPlot=fopen(filename,"rb");
	if(!FpPlot)
	{
		plot_segment(xc,yc,xs,ys,vscale,hscale,0,0);
		FpPlot=fopen(filename,"wb");
		fwrite((char *)&ys,sizeof(int),1,FpPlot);
		fwrite((char *)&xs,sizeof(int),1,FpPlot);
		setbuf(FpPlot,Inbuff3);
		for(i=0;i<ys;i++)
		{
			getrow(0,xc,xc+xs-1,i+yc,ImBuff[0]);
			fwrite((char *)ImBuff[0],sizeof(char),xs,FpPlot);
		}
		if(FpPlot)
			fclose(FpPlot);
	}
	else
	{
		setbuf(FpPlot,Inbuff3);
		fread((char *)&ys,sizeof(int),1,FpPlot);
		fread((char *)&xs,sizeof(int),1,FpPlot);
		for(i=0;i<ys;i++)
		{
			fread((char *)ImBuff[0],sizeof(char),xs,FpPlot);
			plotrow(0,xc,xc+xs-1,i+yc,ImBuff[0]);
		}
		if(FpPlot)
			fclose(FpPlot);
	}
	if(iop==1)
	{
		if(FpRms)
			fclose(FpRms);
		if(FpVal)
			fclose(FpVal);
		SetVideoMode(0);
		return;
	}
	txc=cxc+5;tyc=cyc+5;
	save_sub_mem(txc,tyc,80,15);
	plot_font_h(WHITE,txc,tyc,"Color Scale",2,Font);
	ans=limit_area_seg(&cxc,&cyc,&cxs,&cys,&cspeed,WIDTH,1,(unsigned char *)Buff);
	recall_sub_mem(txc,tyc,80,15);
	Cxc=cxc;Cyc=cyc;Cxs=cxs;Cys=cys;
	if(ans!=27)
	{
		s_box(3,cxc,cyc,L_GREY,cxs,cys);
		Color=1;
		color_bar(cxc,cyc,cxs,cys);
		color_scale(cxc,cyc,cxs,cys);
	}
	if(numtrc/ihscale<=WIDTH/2)
	{
		pxc=WIDTH/2;
		pyc=yc;
	}
	else
	{
		pxc=xc;
		pyc=Ys/2;
	}
	pxs=xs;
	if(plot_map(&mxc,&myc,&mxs,&mys,0)>0)
	{
		Map=1;
		if(pxs>(Xs-mxs-5))pxs=Xs-mxs-5;
	}
	else
		Map=0;
	pys=ys;

	txc=pxc+5;tyc=pyc+5;
	save_sub_mem(txc,tyc,217,15);
	plot_font_h(WHITE,txc,tyc,"Expanded Seismic Segment Window",2,Font);
	limit_area_seg(&pxc,&pyc,&pxs,&pys,&pspeed,WIDTH,1,(unsigned char *)Buff);
	recall_sub_mem(txc,tyc,217,15);
	s_box(3,pxc,pyc,L_GREY,pxs,pys);
	Pxs=pxs;Pys=pys;Pxc=pxc;Pyc=pyc;
	k=2;
	do
	{
		bxs=pxs/k;
		bys=pys/k;
		k+=1;
	}while(bxs>xs||bys>ys);
	bxc=xc;
	byc=yc;
	do
	{
		ans=limit_area_shape(&bxc,&byc,&bxs,&bys,&bspeed,WIDTH,1,Buff[0]);
		if(ans!=27&&ans!=127)
		{
			if(Map==1)
			{
				paint_box(3,D_GREY,Buff[0],mxc,myc,mxs,mys);
				plot_map(&mxc,&myc,&mxs,&mys,1);
				s_box(3,mxc,myc,L_GREY,mxs,mys);
			}
			paint_box(3,D_GREY,Buff[5],pxc,pyc,pxs,pys);
			s_box(3,pxc,pyc,L_GREY,pxs,pys);
			ft1=bxc-xc;
			ft1*=hscale;
			t1=ft1+0.5;
			if(t1<0)t1=0;
			fp1=byc-yc;
			fp1*=vscale;
			p1=fp1+0.5;
			if(p1<0)p1=0;
			tbox(3,bxc,byc,bxs,bys,Buff[6]);
			fxs=pxs;fbxs=bxs;
			fr=fxs/fbxs;
			plot_segment(pxc,pyc,pxs,pys,vscale/fr,hscale/fr,t1,p1);
			Vf=vscale/fr;
			Hf=hscale/fr;
			T1=t1;
			P1=p1;
			unbox(3,bxc,byc,bxs,bys,Buff[6]);
		}
		if(ans==127)
			label_trace(pxc,pyc,pxs,pys,vscale/fr,hscale/fr,t1,p1);
	}while(ans!=27);
	if(FpRms)
		fclose(FpRms);
	if(FpVal)
		fclose(FpVal);
	SetVideoMode(0);
}

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

int limit_area_seg(int *x,int *y,int *xsize,int *ysize,int *speed,
				int maxbox,int iop,unsigned char *buffer)

{
	char ans;
	int size=0,xo,yo,menu=1;
	int spd=*speed;
	int dir=1;
	char string[100];
	int zxc=0,zyc=0,zxs,zys;

	xo=*x;
	yo=*y;

	tbox(3,*x,*y,*xsize,*ysize,buffer); /* plot 1st box on overlay */
	do
	{
		ans=getpad(&size,x,y,speed,menu);	/* use number pad to move box */
		if(ans=='c')dir*=(-1);
		spd=*speed*dir;
		menu=0;	/* turn off menu print */
		unbox(3,xo,yo,*xsize,*ysize,buffer); /* remove old box */
		if(iop==1)            /* change x size */
		{
			if(ans=='x')
				*xsize+=spd;
			if(ans=='y')
				*ysize+=spd;
			if(ans=='n')*xsize-=*speed;
			if(ans=='w')*xsize+=*speed;
			if(ans=='s')*ysize-=*speed;
			if(ans=='h')*ysize+=*speed;
			if(*xsize>maxbox)*xsize=maxbox;
			if(*xsize<0)*xsize=8;
			if(*ysize>maxbox)*ysize=maxbox;
			if(*ysize<0)*ysize=8;
		}
		if(*x<0)*x=0;							/* make sure all is on screen */
		if(*y<0)*y=0;
		if(*x+*xsize>639)*x=639-*xsize;
		if(*y+*ysize>479)*y=479-*ysize;
		tbox(3,*x,*y,*xsize,*ysize,buffer);  /* plot new box on overlay */		
		xo=*x;									/* set old location */
		yo=*y;
	}while(ans!=83&&ans!=13&&ans!=27);
	unbox(3,xo,yo,*xsize,*ysize,buffer); /* remove old box */

	return(ans);
}
/**************************************************************************
**
**
**
************************************************************************* */

int set_video_on(void)

{
	int i,ret;

	i=GetVideoBoardID();
	if(i==0)
		VideoType='E';
	if(i<0)
	{
		printf("Computer will not support enough colors.\n\n");
		exit(0);
	}
	if(VideoType=='X')
	{
		SetVideoMode(480,&B_Id);
		if(B_Id.row==480)
		{
			FNumHue=NumHue=64;
			set_lut('g');
			set_lut('p');
			strcpy(PlotSufx,".xpt");
		}
		else
		{
			if(i>1)
				VideoType='Y';
			else if(i==1)
				VideoType='V';
			else if(i==0)
				VideoType='E';
		}
	}
	if(VideoType=='V')
	{
		FNumHue=NumHue=6;
		ret=SetVideoMode(0x12,&B_Id);
		strcpy(PlotSufx,".vpt");
	}
	if(VideoType=='Y')
	{
		FNumHue=NumHue=64;
		ret=SetVideoMode(400,&B_Id);
		strcpy(PlotSufx,".ypt");
	}
	if(VideoType=='S')
	{
		ret=SetVideoMode(0x13,&B_Id);
		set_lut('G');
		strcpy(PlotSufx,".spt");
	}
	if(VideoType=='E')
	{
		FNumHue=NumHue=6;
		ret=SetVideoMode(0x10,&B_Id);
		strcpy(PlotSufx,".ept");
	}
	Xs=ScreenXs=B_Id.col;
	Ys=ScreenYs=B_Id.row;
	if(ret>=0)
		return(1);
	else
	{
		SetVideoMode(0,&B_Id);
		printf("Could not boot video board\n\n");
		exit(0);
	}
}


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

void color_scale(int xc,int yc,int xs,int ys)

{
	int num=MENU_C-1,ans,ans1,speed=16;
	float fspeed;
	char string[100];
	int zxc=0,zyc=0,zxs,zys;

	fspeed=speed;
	fspeed/=256.0;

	do
	{
		s_box(0,xc,yc,0,xs,ys);
		num=do_menu_buff(menu_c,MENU_C,MENUXC,25,num,D_GREY,L_GREY,WHITE,Font);
		s_box(0,xc,yc,L_GREY,xs,ys);

		if(num==0)
		{
			do
			{
				if((ans=getch())==0)
				{
					ans1=getch();
					if(ans1==71)
						I1+=fspeed;
					if(ans1==72)
						I2+=fspeed;
					if(ans1==73)
						I3+=fspeed;
					if(ans1==79)
						I1-=fspeed;
					if(ans1==80)
						I2-=fspeed;
					if(ans1==81)
						I3-=fspeed;
					if(ans1==75)
						Iadj/=SQRT2;
					if(ans1==77)
						Iadj*=SQRT2;
					set_lut('p');
				}
				if(ans=='-'&&speed>1)
					speed/=2;
				if(ans=='+'&&speed<256)
					speed*=2;
				fspeed=speed;
				fspeed/=256.0;
			}while(ans!=13&&ans!=83);
		}
		if(num==1)
		{
			do
			{
				if((ans=getch())==0)
				{
					ans1=getch();
					if(ans1==71)
						H1+=speed;
					if(ans1==72)
						H2+=speed;
					if(ans1==73)
						H3+=speed;
					if(ans1==79)
						H1-=speed;
					if(ans1==80)
						H2-=speed;
					if(ans1==81)
						H3-=speed;
					if(ans1==75)
						Hadj/=SQRT2/2.0;
					if(ans1==77)
						Hadj*=SQRT2/2.0;
					set_lut('p');
				}
				if(ans=='-'&&speed>1)
					speed/=2;
				if(ans=='+'&&speed<256)
					speed*=2;
				fspeed=speed;
				fspeed/=256.0;
			}while(ans!=13&&ans!=83);
		}
		if(num==2)
		{
			do
			{
				if((ans=getch())==0)
				{
					ans1=getch();
					if(ans1==71)
						S1+=fspeed;
					if(ans1==72)
						S2+=fspeed;
					if(ans1==73)
						S3+=fspeed;
					if(ans1==79)
						S1-=fspeed;
					if(ans1==80)
						S2-=fspeed;
					if(ans1==81)
						S3-=fspeed;
					if(ans1==75)
						Sadj/=SQRT2;
					if(ans1==77)
						Sadj*=SQRT2;
					set_lut('p');
				}
				if(ans=='-'&&speed>1)
					speed/=2;
				if(ans=='+'&&speed<256)
					speed*=2;
				fspeed=speed;
				fspeed/=256.0;
			}while(ans!=13&&ans!=83);
		}
		if(num==3)
		{
			I1=0.5;I2=0.5;I3=1.0;Iadj=0.5;
			H1=0.0;H2=155.0;H3=0.0;Hadj=1.0;
			S1=S2=S3=1.0;Sadj=1.0;
			set_lut('p');
		}
		if(num==4)
		{
			I1=0.0;I2=0.0;I3=1.0;Iadj=0.5;
			H1=0.0;H2=155.0;H3=0.0;Hadj=1.0;
			S1=S2=S3=0.0;Sadj=1.0;
			set_lut('p');
		}
	}while(num<MENU_C-1&&ans!=83);
}


/********************************************************************
**
**     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(char *menu[],int num,int xc,int yc,int start,
				int back,int words,int 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,ImBuff,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,ImBuff,
						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(int xc,int yc,int xs,int ys)

{
	int i,j,k;

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

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

int recall_sub_mem(int xc,int yc,int xs,int ys)

{
	int i,j,k;

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





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

void color_bar(int xc,int yc,int xs,int ys)

{
	int i,j,k;
	int cxc=xc+5,cyc=yc+5,cxs=xs-10,cys=ys-30,val;
	float fxs,fx;

	if(cys<1||cxs<16)
		return;

	fxs=cxs/2;
	for(i=1;i<cxs/2;i++)
	{
		fx=i;
		val=FNumHue-fx/fxs*FNumHue+4;
		for(j=0;j<cys;j++)
			plotpt(3,cxc+i,cyc+j,val);
	}
	for(i=cxs/2;i<cxs;i++)
	{
		fx=i-cxs/2;
		val=fx/fxs*FNumHue+(FNumHue+4);
		for(j=0;j<cys;j++)
			plotpt(3,cxc+i,cyc+j,val);
	}
	fxs=cxs;
	fxs/=6.0;
	fx=cxc;
	i=fx;
	plotln(3,i,cyc+cys-5,i,cyc+cys+3,WHITE);
	plot_font_h(WHITE,i-4,cyc+cys+5,"-3",3,Font);
	fx+=fxs;
	i=fx;
	plotln(3,i,cyc+cys-5,i,cyc+cys+3,WHITE);
	plot_font_h(WHITE,i-4,cyc+cys+5,"-2",3,Font);
	fx+=fxs;
	i=fx;
	plotln(3,i,cyc+cys-5,i,cyc+cys+3,WHITE);
	plot_font_h(WHITE,i-4,cyc+cys+5,"-1",3,Font);
	fx+=fxs;
	i=fx;
	plotln(3,i,cyc+cys-5,i,cyc+cys+3,WHITE);
	plot_font_h(WHITE,i-2,cyc+cys+5,"0",3,Font);
	fx+=fxs;
	i=fx;
	plotln(3,i,cyc+cys-5,i,cyc+cys+3,WHITE);
	plot_font_h(WHITE,i-2,cyc+cys+5,"1",3,Font);
	fx+=fxs;
	i=fx;
	plotln(3,i,cyc+cys-5,i,cyc+cys+3,WHITE);
	plot_font_h(WHITE,i-2,cyc+cys+5,"2",3,Font);
	fx+=fxs;
	i=fx;
	plotln(3,i,cyc+cys-5,i,cyc+cys+3,WHITE);
	plot_font_h(WHITE,i-2,cyc+cys+5,"3",3,Font);
	plot_font_h(WHITE,cxc+cxs/2-7,cyc+cys+15,"RMS",3,Font);
}


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

int plot_map(int *pxc,int *pyc,int *pxs,int *pys,int iop)

{
	int i,j,k;
	FILE *fpmap;
	char infile[100];
	int xc=WIDTH/2,yc=Ys/2,xs,ys,speed=16;
	int xmax=-1,xmin=30000,ymax=-1,ymin=30000;
	char string[100],string2[100],ans;
	int ix,iy,i0,y0,val,ixo,iyo;
	float xscale,yscale,scale,y1,y2,x,y;
	int status=1;
	int txc,tyc,txs=300,tys=15;

	strcpy(string,InFile);
	strcat(string,".map");
	fpmap=fopen(string,"rb");
	if(!fpmap)
	{
		return(-1);
	}
	setbuf(fpmap,Inbuff4);
	if(iop==0||iop==3)
	{
		do
		{
			fscanf(fpmap,"%s",string);
			if(string[0]!='*')
			{
				fscanf(fpmap,"%d%d",&ix,&iy);
				if(ix>xmax)xmax=ix;
				if(ix<xmin)xmin=ix;
				if(iy>ymax)ymax=iy;
				if(iy<ymin)ymin=iy;
			}
		}while(string[0]!='*');	
		while(fscanf(fpmap,"%d",&val)==1)
		{
			do
			{
				fscanf(fpmap,"%s%s",string,string2);
				sscanf(string,"%d",&ix);
				sscanf(string2,"%d",&iy);
				if(ix>xmax)xmax=ix;
				if(ix<xmin)xmin=ix;
				if(iy>ymax)ymax=iy;
				if(iy<ymin)ymin=iy;
			}while(string2[strlen(string2)-1]!='/');
		}
		if(fpmap)
			rewind(fpmap);
		xscale=xmax-xmin;
		xscale=(float)WIDTH/xscale;
		yscale=ymax-ymin;
		scale=yscale=(float)Ys/yscale;
		if(xscale<scale)
			scale=xscale;
		scale/=2.0;
		*pxs=xs=(float)(xmax-xmin)*scale;
		*pys=ys=(float)(ymax-ymin)*scale;
		*pxc=xc=Xs-xs-1;
		*pyc=yc=Ys-ys-55;

		txc=*pxc+5;tyc=*pyc+5;
		if(iop==0)
		{
			save_sub_mem(txc,tyc,98,15);
			plot_font_h(WHITE,txc,tyc,"Shot Point Map",2,Font);
			ans=limit_area_shape(pxc,pyc,pxs,pys,&speed,WIDTH,1,Buff[0]);
			recall_sub_mem(txc,tyc,98,15);
		}
		else
			ans=13;
		if(ans!=27)
		{
			if(*pys!=ys)
			{
				y1=ys;
				y2=*pys;
				scale*=y2/y1;
			}
			xc=*pxc;
			yc=*pyc;
			xs=*pxs;
			ys=*pys;
		}
		else
		{
			status=0;
			return(status);
		}
		s_box(3,*pxc,*pyc,L_GREY,*pxs,*pys);
		Map_Xmin=xmin;
		Map_Ymin=ymin;
		Map_Scale=scale;
	}
	else
	{
			xmin=Map_Xmin;
			ymin=Map_Ymin;
			scale=Map_Scale;
			xc=*pxc;
			yc=*pyc;
			xs=*pxs;
			ys=*pys;
			paint_box(3,D_GREY,Buff[0],xc,yc,xs,ys);
	}
	do
	{
		fscanf(fpmap,"%s",string);
		if(string[0]!='*')
		{
			fscanf(fpmap,"%d%d",&ix,&iy);
			x=ix-xmin;y=iy-ymin;			
			x*=scale;y*=scale;
			ix=xc+x;iy=yc+y;
			plot_font_h(WHITE,ix,iy,string,3,Font);
		}
	}while(string[0]!='*');	
	while(fscanf(fpmap,"%d",&val)==1)
	{
		i=0;
		do
		{
			fscanf(fpmap,"%s%s",string,string2);
			sscanf(string,"%d",&ix);
			sscanf(string2,"%d",&iy);
			x=ix-xmin;y=iy-ymin;			
			x*=scale;y*=scale;
			ix=xc+x;iy=yc+y;
			if(val>=300&&val<400)
			{
				Shot_X[i]=ix;
				Shot_Y[i]=iy;
				Num_Shots=i+1;
			}
			if(i>0)
			{
				if(val<100)
					plotln(3,ix,iy,ixo,iyo,L_GREY);
				else if(val<200)
					plotln(3,ix,iy,ixo,iyo,Yellow);
				else if(val<300)
					plotln(3,ix,iy,ixo,iyo,Cyan);
				else if(val<400)
					plotln(3,ix,iy,ixo,iyo,Red);
			}
			ixo=ix;iyo=iy;
			i+=1;
		}while(string2[strlen(string2)-1]!='/');
	}
	if(fpmap)
		fclose(fpmap);
	return(status);
}


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

void plot_segment(int xc,int yc,int xs,int ys,float vscale,float hscale,
					int t1,int p1)

{
	int i,j,k,ip,x=0,y=0,j1,j2,io=-1,t=t1,xt,xt1,xt2,tx,ty,td,m,n,ii;
	int k1,k2,isize,inum;
	char ans;
	char filename[100];
	int val,numpts,blksize,plotpts;
	int ivscale=vscale,ihscale=hscale;
	double rms,dnum,nnum,srms,max_rms,min_rms;
	double dval,ddat,nval,dval1,dval2,dsign;
	long offskip,offset;
	float fi,fdi=1.0/hscale,foff,fys=ys,fj;
	float c_scale=FNumHue/3.0;
	float fsy,fy,fnumpts,sign;
	int iy,iy1,iy2,ixo,iyo;
	char number[100];
	int mark,spacing=S.map_space*S.point_space,mark_on=0;

	if(Power==1)
		Cor=3.0*MeanRMS/(Hi-Lo);
	xs-=14;
	j1=p1;
	j2=p1+ys;
	if(FpVal)
		rewind(FpVal);
	if(FpRms)
		rewind(FpRms);
	blksize=S.block_size;
	numpts=(S.block_size-240)/4;
	fnumpts=numpts;
	plotpts=numpts/vscale;
	if(plotpts>Ys)
		plotpts=Ys-1;
	fi=i=0;
	if(!FpVal||!FpRms)
	{
		SetVideoMode(0);
		printf("Could not find ___.val or ___.rms files.  Run option 'm'.\n\n");
		return;
	}
	else if(hscale>=1.0)
	{
		for(fj=0.0;fj<fnumpts;fj+=S.time_line)
		{
			iy2=(int)(fj-j1)/vscale+yc;
			if(iy2>yc&&iy2<yc+ys-1)
				plotln(3,xc,iy2,xc+xs-1,iy2,WHITE);
			if(iy2>yc&&iy2<(yc+ys-4))
			{
				sprintf(number,"%2.0f",fj/S.time_line);
				plot_font_h(WHITE,xc+xs+3,iy2-3,number,3,Font);
			}
		}
		offskip=numpts*(ihscale-1)*sizeof(long);
		offset=numpts*sizeof(long);
		offset*=t1;
		fseek(FpVal,offset,SEEK_SET);
		offset=sizeof(double);
		offset*=t1;
		fseek(FpRms,offset,SEEK_SET);
		while(i<640&&i<xs-1&&
			fread((char *)Data,sizeof(float),numpts,FpVal)==numpts)
		{
			if(kbhit()>0)
			{
				val=getch();
				if(val==27)
					return;
			}
			if(Power==1)
				power_data(Data,numpts);
			fread((char *)&rms,sizeof(double),1,FpRms);
			fi+=fdi;
			i=fi;
			if(Map>0)
			{
				xt=S.map_point1-S.first_point+(t++);
				xt1=xt;
				if(xt1%spacing==0)
				{
					mark_on=1;
					mark=1;
				}
				else
					mark=0;
				xt1/=S.map_space*S.point_space;
				tx=Shot_X[xt1];
				ty=Shot_Y[xt1];
				if(mark_on==1)
					for(m=-1;m<2;m++)
						for(n=-1;n<2;n++)
							plotpt(3,tx+m,ty+n,WHITE);
			}
			if(i!=io&&i<xc+xs)
			{
				for(j=j1+1;j<j2;j++)
				{
					val=0.0;
					k1=(float)(j-j1)*vscale+j1;
					k2=(float)(j-j1+1)*vscale-1.0+j1;
					if(k2<k1)k2=k1;
					sign=dval=dnum=nval=nnum=0.0;
					for(k=k1;k<=k2;k++)
					{
						if(Data[k]>0.0)
						{
							dval+=Data[k];
							dnum+=1.0;
						}
						else
						{
							nval-=Data[k];
							nnum+=1.0;
						}
					}
					if(nval>dval)
					{
						dval=nval*(-1.0);
						dnum=nnum;
						sign=-1;
					}
					if(dnum>0.0)
						dval/=dnum;
					if(RMS_Mean==1&&rms!=0.0)
						rms=MeanRMS;						
					if(rms>0.0)
						dval=(dval/rms)*c_scale;
					else
						dval=0.0;
					if(dval>=0.0)
					{
						val=dval;
						if(val>=NumHue)
							val=NumHue-1;
						val+=4;
					}
					else
					{
						val=dval*(-1);
						if(val>=NumHue)
							val=NumHue-1;
						val+=NumHue+4;
					}
					if(i>0&&i<xs-2)
						plotpt(3,i+xc,j-j1+yc,val);
				}
			}
			if(mark==1&&Map==1)
			{
				plotln(3,i+xc,yc,i+xc,yc+5,WHITE);
				plotln(3,i+xc,yc+ys-1,i+xc,yc+ys-6,WHITE);
			}
			io=i;
		}
	}
	else if(hscale<1.0&&vscale>=1.0)
	{
		for(fj=0.0;fj<fnumpts;fj+=S.time_line/5.0)
		{
			iy2=(int)(fj-j1)/vscale+yc;
			if(iy2>yc&&iy2<yc+ys-1)
				plotln(3,xc,iy2,xc+xs-1,iy2,L_GREY);
		}
		for(fj=0.0;fj<fnumpts;fj+=S.time_line)
		{
			iy2=(int)(fj-j1)/vscale+yc;
			if(iy2>yc&&iy2<yc+ys-1)
				plotln(3,xc,iy2,xc+xs-1,iy2,WHITE);
			if(fj>0.0&&(iy2+3)<(yc+ys-1))
			{
				sprintf(number,"%2.0f",fj/S.time_line);
				if(iy2>yc&&iy2<(yc+ys-5))
					plot_font_h(WHITE,xc+xs+3,iy2-3,number,3,Font);
			}
		}
		offskip=numpts*(ihscale-1)*sizeof(long);
		offset=numpts*sizeof(long);
		offset*=t1;
		fseek(FpVal,offset,SEEK_SET);
		offset=sizeof(double);
		offset*=t1;
		fseek(FpRms,offset,SEEK_SET);
		io=-9999;
		while(i<xs-1&&
			fread((char *)Data,sizeof(float),numpts,FpVal)==numpts)
		{
			if(kbhit()>0)
			{
				val=getch();
				if(val==27)
					return;
			}
			if(Power==1)
				power_data(Data,numpts);
			if(Map>0)
			{
				xt=S.map_point1-S.first_point+(t++);
				xt1=xt;
				if(xt1%spacing==0)
				{
					mark_on=1;
					mark=1;
				}
				else
					mark=0;
				xt1/=S.map_space*S.point_space;
				tx=Shot_X[xt1];
				ty=Shot_Y[xt1];
				if(mark_on==1)
					for(m=-1;m<2;m++)
						for(n=-1;n<2;n++)
							plotpt(3,tx+m,ty+n,WHITE);
			}
			fread((char *)&rms,sizeof(double),1,FpRms);
			if(RMS_Mean==1&&rms!=0.0)
				rms=MeanRMS;						
			fi+=fdi;
			i=fi;
			if(i<xc+xs)
			{
				for(j=j1+1;j<j2;j++)
				{
					val=0.0;
					k1=(float)(j-j1)*vscale+j1;
					k2=(float)(j-j1+1)*vscale-1.0+j1;
					if(k2<k1)k2=k1;
					dval=dnum=nval=nnum=0.0;
					for(k=k1;k<=k2;k++)
					{
						if(Data[k]>0.0)
						{
							dval+=Data[k];
							dnum+=1.0;
						}
						else
						{
							nval-=Data[k];
							nnum+=1.0;
						}
					}
					if(nval>dval&&nnum>0.0)
					{
						dval=nval*(-1.0);
						dnum=nnum;
					}
					if(dnum>0.0)
						dval/=dnum;
					if(rms>0.0)
						dval=(dval/rms)*c_scale;
					else
						dval=0.0;
					if(dval>=FNumHue)dval=FNumHue-1;
					if(dval>=0.0)
					{
						val=dval;
						if(val>=NumHue)
							val=NumHue-1;
						val=dval+FNumHue+4;
					}
					else
					{
						val=dval*(-1);
						if(val>=NumHue)
							val=NumHue-1;
						val+=4;
					}
					if(io!=-9999&&i<xs-2)
					{
						if(io>=0&&i-io>1)
						{
							for(ii=io+1;ii<=i;ii++)
							{
								plotpt(3,ii+xc,j-j1+yc,val);
							}
						}
						else
							plotpt(3,i+xc,j-j1+yc,val);
					}
				}
				io=i;
			}
			if(mark==1)
			{
				plotln(3,i+xc,yc,i+xc,yc+5,WHITE);
				plotln(3,i+xc,yc+ys-1,i+xc,yc+ys-6,WHITE);
			}
		}
	}
	else
	{
		for(fj=0.0;fj<fnumpts;fj+=S.time_line/10.0)
		{
			iy2=(int)(fj-j1)/vscale+yc;
			if(iy2>yc&&iy2<yc+ys-1)
				plotln(3,xc,iy2,xc+xs-1,iy2,L_GREY);
		}
		for(fj=0.0;fj<fnumpts;fj+=S.time_line)
		{
			iy2=(int)(fj-j1)/vscale+yc;
			if(iy2>yc&&iy2<yc+ys-1)
				plotln(3,xc,iy2,xc+xs-1,iy2,WHITE);
			if(fj>0.0&&(iy2+3)<(yc+ys-1))
			{
				sprintf(number,"%2.0f",fj/S.time_line);
				if(iy2>yc&&iy2<(yc+ys-5))
					plot_font_h(WHITE,xc+xs+3,iy2-3,number,3,Font);
			}
		}
		j2=fys*vscale;
		j2+=p1;
		offskip=numpts*(ihscale-1)*sizeof(long);
		offset=numpts*sizeof(long);
		offset*=t1;
		fseek(FpVal,offset,SEEK_SET);
		offset=sizeof(double);
		offset*=t1;
		fseek(FpRms,offset,SEEK_SET);
		while(i<640&&i<xs-1&&
			fread((char *)Data,sizeof(float),numpts,FpVal)==numpts)
		{
			if(kbhit()>0)
			{
				val=getch();
				if(val==27)
					return;
			}
			if(Power==1)
				power_data(Data,numpts);
			fread((char *)&rms,sizeof(double),1,FpRms);
			if(RMS_Mean==1&&rms!=0.0)
				rms=MeanRMS;						
			if(Map>0)
			{
				xt=S.map_point1-S.first_point+(t++);
				xt1=xt;
				if(xt1%spacing==0)
				{
					mark_on=1;
					mark=1;
				}
				else
					mark=0;
				xt1/=S.map_space*S.point_space;
				tx=Shot_X[xt1];
				ty=Shot_Y[xt1];
				if(mark_on==1)
					for(m=-1;m<2;m++)
						for(n=-1;n<2;n++)
							plotpt(3,tx+m,ty+n,WHITE);
			}
			fi+=fdi;
			i=fi;
			for(j=j1;j<j2;j++)
			{
				dval=Data[j];
				if(rms>0.0)
					dval=(dval/rms)*c_scale;
				else
					dval=0.0;
				if(dval>=0.0)
				{
					val=dval;
					if(val>=NumHue)
						val=NumHue-1;
					val+=NumHue+4;
				}
				else
				{
					val=dval*(-1.0);
					if(val>=NumHue)
						val=NumHue-1;
					val+=4;
				}
				fj=j-j1;
				fj/=vscale;
				dval/=100.0*hscale;

				isize=dval*Gain;

				if(dval>=0.0)
				{
					for(k=0;k<=isize;k++)
					{
						if(i+k<xs-1&&(int)fj>0&&getpt(3,i+xc+k,(int)fj+yc)==D_GREY)
							plotpt(3,i+xc+k,(int)fj+yc,val);
					}
				}
				else
					if(i+isize>0&&i+isize<xs-1&&(int)fj>0&&
													getpt(3,i+xc+isize,(int)fj+yc)==D_GREY)
						plotpt(3,i+xc+isize,(int)fj+yc,val);

				if(j>j1)
				{
					dval1=Data[j-1];
					fj=(j-1)-j1;
					fj/=vscale;
					iy1=(int)fj+yc;
					dval2=Data[j];
					fj=j-j1;
					fj/=vscale;
					iy2=(int)fj+yc;
					fsy=iy2-iy1;
					if(fsy>0.0)
					{
						for(iy=iy1;iy<iy2;iy++)
						{
							fy=iy-iy1;
							dval=fy/fsy*(dval2-dval1)+dval1;
							dval=(dval/rms)*c_scale;
							if(dval>=0.0)
							{
								val=dval;
								if(val>=NumHue)
									val=NumHue-1;
								val+=NumHue+4;
							}
							else
							{
								val=dval*(-1.0);
								if(val>=NumHue)
									val=NumHue-1;
								val+=4;
							}
							dval/=100.0*hscale;
			
							isize=dval*Gain;

							if(iy>iy1&&i+isize<xs-1&&i+isize>0&&iyo>xc&&iyo<xc+xs-2)
								plotln(3,i+xc+isize,iy,ixo,iyo,val);
							if(dval>0.0)
							{
								for(k=0;k<=isize;k++)
								{
									if(i+k<xs-1&&i>0&&iy>yc
													&&getpt(3,i+xc+k,iy)==D_GREY)
										plotpt(3,i+xc+k,iy,val);
								}
							}
							else
								if(i+isize<xs-1&&i+isize>0&&i+isize<xs-1&&iy>0
												&&getpt(3,i+xc+isize,iy)==D_GREY)
									plotpt(3,i+xc+isize,iy,val);
							ixo=i+xc+isize;iyo=iy;
						}
					}
				}
			}
			if(mark==1)
			{
				plotln(3,i+xc,yc,i+xc,yc+5,WHITE);
				plotln(3,i+xc,yc+ys-1,i+xc,yc+ys-6,WHITE);
			}
		}
	}
}

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

int power_data(float *data,int numpts)

{
	int ip;
	double dval,dsign;
	long expon,sign,*ldata=(long *)data;
	float fsign,fval;

	for(ip=0;ip<numpts;ip++)
	{
		if(*ldata!=0);
		{
			expon=(*ldata&MSK_EXP_IEEE)>>23;
			if((*ldata&MSK_SIGN_IEEE)==MSK_SIGN_IEEE)
				fsign=1.0;
			else
				fsign=-1.0;
			*data=expon-Lo;
			if(*data<0.0)
				*data=0.0;
			*data*=Cor;
			*data*=fsign;
		}
		ldata++;
		data++;
	}
}




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

double decode_line(int numpts,unsigned char *buff,float *data)

{
	int i,j,k;
	int offset=240;
	float fdata,fval;
	double rms=0.0,pts=numpts,ddata,used=0.0;
	double dval,pval,base=16.0;
	int val1,val2,val3,val4;
	double frac,sign,power;

	if(numpts<=0)return(-1.0);

	for(i=0;i<numpts;i++)
	{
		val1=buff[i*4+offset];
		val2=buff[i*4+1];
		val3=buff[i*4+2];
		val4=buff[i*4+3];

		sign=1.0;
		if((val1&128)==128)
			sign=-1.0;
		power=val1&127;
		power-=64.0;

		frac=val4;
		frac/=256;
		frac+=val3;
		frac/=256;
		frac+=val2;
		frac/=256;
		if(power>-16.0&&power<16.0)	
			fval=pow(base,power)*frac*sign;
		else
			fval=0.0;
		ddata=data[i]=fval;
		if(fval<-10.0||fval>10.0)
		{
			rms+=ddata*ddata;
			used+=1.0;
		}
	}
	if(used>0.0)
	{
		rms/=used;
		if(rms>0.0)
			rms=sqrt(rms);
	}
	else
		rms=0.0;
	return(rms);
}



/********************************************************************
**
**	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
**
********************************************************************* */

void set_lut(char type)

{
	int i,k,hue,brite,j;
	float color[3];
	double dbrite,dval;
	float val,minval,sat,inten;
	float fval,fk;
	int numcolor=256;
	long dred=167772,dgreen=167772,dcyan=167772,dyellow=167772;
	long d;

	if(VideoType!='X'&&VideoType!='Y'&&VideoType!='S')
		numcolor=16;
	if(type=='p')
	{
		lut[0].r=lut[0].g=lut[0].b=0;
		lut[1].r=lut[1].g=lut[1].b=46;
		lut[2].r=lut[2].g=lut[2].b=191;
		lut[3].r=lut[3].g=lut[3].b=255;
		for(k=4;k<4+NumHue;k++) 
		{ 
			fk=k-4;
			hue=(fk+0.5)/(FNumHue-0.5)*(H1-H2*Hadj)+H2*Hadj;
			while(hue<0)hue+=256;
			while(hue>255)hue-=256;
			sat=(fk+0.5)/(FNumHue-0.5)*(S1-S2*Sadj)+S2*Sadj;
			while(sat<0.0)sat+=1.0;
			while(sat>1.0)sat-=1.0;
			inten=(fk+0.5)/(FNumHue-0.5)*(I1-I2*Iadj)+I2*Iadj;
			while(inten<0.0)inten+=1.0;
			while(inten>1.0)inten-=1.0;
			for(i=0;i<3;i++)
			{
				color[i]=maxhues[hue][i];
				color[i]+=(255.0-color[i])*(1.0-sat);
				color[i]*=inten;
			}
			lutc[k].r=lut[k].r=color[0];
			lutc[k].g=lut[k].g=color[1];
			lutc[k].b=lut[k].b=color[2];
		}
		for(k=(4+NumHue);k<(4+NumHue*2);k++)
		{ 
			fk=k-(4+NumHue);
			hue=(fk+0.5)/(FNumHue-0.5)*(H3-H2)+H2;
			while(hue<0)hue+=256;
			while(hue>255)hue-=256;
			sat=(fk+0.5)/(FNumHue-0.5)*(S3-S2)+S2;
			while(sat<0.0)sat+=1.0;
			while(sat>1.0)sat-=1.0;
			inten=(fk+0.5)/(FNumHue-0.5)*(I3-I2)+I2;
			while(inten<0.0)inten+=1.0;
			while(inten>1.0)inten-=1.0;
			for(i=0;i<3;i++)
			{
				color[i]=maxhues[hue][i];
				color[i]+=(255.0-color[i])*(1.0-sat);
				color[i]*=inten;
			}
			lutc[k].r=lut[k].r=color[0];
			lutc[k].g=lut[k].g=color[1];
			lutc[k].b=lut[k].b=color[2];
		}
	}
	if(type=='c')
	{
		for(k=15;k<256;k++) 
		{ 
			lutc[k].r=lut[k].r=k; 
			lutc[k].g=lut[k].g=k; 
			lutc[k].b=lut[k].b=k; 
		} 
		lut[ 0].r=  0;lut[ 0].g=  0;lut[ 0].b=  0;
		lut[ 1].r= 46;lut[ 1].g= 46;lut[ 1].b= 46;
		lut[ 2].r=128;lut[ 2].g=128;lut[ 2].b=128;
		lut[ 3].r=255;lut[ 3].g=255;lut[ 3].b=255;
		lut[ 4].r=255;lut[ 4].g=  0;lut[ 4].b=  0;
		lut[ 5].r=255;lut[ 5].g=128;lut[ 5].b=  0;
		lut[ 6].r=  0;lut[ 6].g=160;lut[ 6].b=  0;
		lut[ 7].r=  0;lut[ 7].g= 80;lut[ 7].b=  0;
		lut[ 8].r=  0;lut[ 8].g= 40;lut[ 8].b=  0;
		lut[ 9].r= 64;lut[ 9].g= 64;lut[ 9].b=255;
		lut[10].r=  0;lut[10].g= 70;lut[10].b= 70;
		lut[11].r=115;lut[11].g= 99;lut[11].b= 82;
		lut[12].r= 96;lut[12].g= 28;lut[12].b= 14;
		lut[13].r=128;lut[13].g=128;lut[13].b=255;
		lut[14].r=105;lut[14].g= 90;lut[14].b= 75;
		lut[15].r=  0;lut[15].g= 20;lut[15].b= 60;
	}
	if(type=='g')
	{
		for(k=0;k<256;k++) 
		{ 
			lutc[k].r=lut[k].r=k; 
			lutc[k].g=lut[k].g=k; 
			lutc[k].b=lut[k].b=k; 
		} 
	}
	if(type=='G')
	{
		for(k=0;k<256;k++) 
		{ 
			lut[k].r=k; 
			lut[k].g=k; 
			lut[k].b=k; 
		} 
	}
	if(type=='i')
	{
		for(k=0;k<256;k++) 
		{ 
			lutc[k].r=lut[k].r=k; 
			lutc[k].g=lut[k].g=k; 
			lutc[k].b=lut[k].b=k; 
		} 
		lut[ 64].r=  0;lut[ 64].g=  0;lut[ 64].b=128;
		lut[127].r=  0;lut[127].g=100;lut[127].b=  0;
		lut[191].r=255;lut[191].g=  0;lut[191].b=  0;
		lut[192].r=255;lut[192].g=128;lut[192].b=  0;
		lut[193].r=255;lut[193].g=255;lut[193].b=  0;
		lut[194].r=  0;lut[194].g=255;lut[194].b=  0;
		lut[195].r=  0;lut[195].g=255;lut[195].b=255;
		lut[196].r= 20;lut[196].g= 55;lut[196].b=255;
		lut[253].r=100;lut[253].g=  1;lut[253].b=  1;
		lut[254].r=100;lut[254].g=  1;lut[254].b=  1;
	}
	if(type=='r')
	{
		for(k=0;k<256;k++) 
		{ 
			lut[k].r=lutc[k].r; 
			lut[k].g=lutc[k].g; 
			lut[k].b=lutc[k].b;
		} 
	}
	for(i=0;i<numcolor;i++)
	{
		d=((long)lut[i].r-(long)C_Red[0])*((long)lut[i].r-(long)C_Red[0])+
		  ((long)lut[i].g-(long)C_Red[1])*((long)lut[i].g-(long)C_Red[1])+
		  ((long)lut[i].b-(long)C_Red[2])*((long)lut[i].b-(long)C_Red[2]);
		if(d<dred)
		{
			dred=d;
			Red=i;
		}
		d=((long)lut[i].r-(long)C_Green[0])*((long)lut[i].r-(long)C_Green[0])+
		  ((long)lut[i].g-(long)C_Green[1])*((long)lut[i].g-(long)C_Green[1])+
		  ((long)lut[i].b-(long)C_Green[2])*((long)lut[i].b-(long)C_Green[2]);
		if(d<dgreen)
		{
			dgreen=d;
			Green=i;
		}
		d=((long)lut[i].r-(long)C_Yellow[0])*((long)lut[i].r-(long)C_Yellow[0])+
		  ((long)lut[i].g-(long)C_Yellow[1])*((long)lut[i].g-(long)C_Yellow[1])+
		  ((long)lut[i].b-(long)C_Yellow[2])*((long)lut[i].b-(long)C_Yellow[2]);
		if(d<dyellow)
		{
			dyellow=d;
			Yellow=i;
		}
		d=((long)lut[i].r-(long)C_Cyan[0])*((long)lut[i].r-(long)C_Cyan[0])+
		  ((long)lut[i].g-(long)C_Cyan[1])*((long)lut[i].g-(long)C_Cyan[1])+
		  ((long)lut[i].b-(long)C_Cyan[2])*((long)lut[i].b-(long)C_Cyan[2]);
		if(d<dcyan)
		{
			dcyan=d;
			Cyan=i;
		}
	}
	WritePalette(lut); 
}

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

char limit_area_shape(int *x,int *y,int *xsize,int *ysize,int *speed,
			int maxbox,int iop,unsigned char *buffer)

{
	char ans,ansc;
	int size=0,xo,yo,menu=1;
	int spd=*speed;
	int dir=1;
	float fxs=*xsize,fys=*ysize,fr;
	char string[100];
	int zxc=0,zyc=0,zxs,zys;

	fr=fxs/fys;

	xo=*x;
	yo=*y;

	tbox(3,*x,*y,*xsize,*ysize,buffer); /* plot 1st box on overlay */
	do
	{
		ans=getpad(&size,x,y,speed,menu);	/* use number pad to move box */

		if(ans=='p')
		{
			s_box(3,*x,*y,WHITE,*xsize-1,*ysize-1);
			print_screen();
		}
		if(ans=='g')
		{
			do
			{
				ansc=getch();
				if(ansc=='+'||ansc=='-')
				{
					if(ansc=='+')Gain*=1.414;
					if(ansc=='-')Gain/=1.414;
/*
					paint_box(3,D_GREY,Buff[0],Pxc,Pyc,Pxs,Pys);
					s_box(3,Pxc,Pyc,L_GREY,Pxs,Pys);
					plot_segment(Pxc,Pyc,Pxs,Pys,Vf,Hf,T1,P1);
*/
				}
			}while(ansc=='+'||ansc=='-');
		}
		if(ans=='c')
			color_scale(Cxc,Cyc,Cxs,Cys);
		if(ans=='L')
		{
			ans=127;
		}
		if(ans=='b')
		{
			do
			{
				ansc=getch();
				if(ansc==0)
				{
					ansc=getch();
					if(ansc==71)
						lut[D_GREY].r+=spd;
					if(ansc==72)
						lut[D_GREY].g+=spd;
					if(ansc==73)
						lut[D_GREY].b+=spd;
					if(ansc==79)
						lut[D_GREY].r-=spd;
					if(ansc==80)
						lut[D_GREY].g-=spd;
					if(ansc==81)
						lut[D_GREY].b-=spd;
					WritePalette(lut); 
				}
			}while(ansc!=13);
		}
		if(ans=='c')dir*=(-1);
		spd=*speed*dir;
		menu=0;	/* turn off menu print */
		unbox(3,xo,yo,*xsize,*ysize,buffer); /* remove old box */
		if(iop==1)            /* change x size */
		{
			if(ans=='s')*ysize-=*speed;
			if(ans=='l')*ysize+=*speed;
			fys=*ysize;
			fxs=fr*fys;	
			*xsize=fxs+0.5;
			if(*xsize>maxbox)*xsize=maxbox;
			if(*xsize<0)*xsize=2;
			if(*ysize>maxbox)*ysize=maxbox;
			if(*ysize<0)*ysize=2;
		}
		if(*x<0)*x=0;							/* make sure all is on screen */
		if(*y<0)*y=0;
		if(*x+*xsize>=WIDTH)*x=WIDTH-*xsize-1;
		if(*y+*ysize>=Ys)*y=Ys-*ysize-1;
		tbox(3,*x,*y,*xsize,*ysize,buffer);  /* plot new box on overlay */		
		xo=*x;									/* set old location */
		yo=*y;
	}while(ans!=83&&ans!=13&&ans!=27&&ans!=127);
	unbox(3,xo,yo,*xsize,*ysize,buffer); /* remove old box */
	return(ans);
}

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

void label_trace(int xc,int yc,int xs,int ys,float vscale,float hscale,
			int t1,int p1)

{
	int i,j,k,x=0,y=0,j1,j2,io=-1,t=t1,xt,xt1,xt2,tx,ty,td,m,n;
	int k1,k2,isize,inum;
	int x1,x2;
	char ans;
	char filename[100];
	int val,numpts,blksize,plotpts;
	int ivscale=vscale,ihscale=hscale;
	double rms,dnum,nnum,srms,max_rms,min_rms;
	double dval,ddat,nval,dval1,dval2;
	long offskip,offset;
	float fi,fdi=1.0/hscale,foff,fys=ys,fj;
	float c_scale=21.333333;
	float fsy,fy,fnumpts;
	int iy,iy1,iy2,ixo,iyo;
	char number[100];
	int mark,spacing=S.map_space*S.point_space,mark_on=0;

	xs-=14;
	j1=p1;
	j2=p1+ys;

	blksize=S.block_size;
	numpts=(S.block_size-240)/4;
	fnumpts=numpts;
	plotpts=numpts/vscale;
	if(plotpts>Ys)
		plotpts=Ys-1;
	fi=i=0;

	if(hscale>=1.0)
	{
		offset=t1;
		while(i<640&&i<xs-1)
		{
			fi+=fdi;
			i=fi;
			xt=S.first_point+(t++);
			xt1=xt;
			if(xt1%spacing==0)
			{
				sprintf(number,"%d",xt1/S.point_space);
				x1=i+xc-strlen(number)*5/2-1;
				x2=x1+strlen(number)*5-2;
				if(x1>=xc&&x2<xc+xs)
					plot_font_h(WHITE,x1,yc+5,number,3,Font);
			}
		}
	}
	else if(hscale<1.0&&vscale>=1.0)
	{
		while(i<xs-1)
		{
			fi+=fdi;
			i=fi;
			xt=S.first_point+(t++);
			xt1=xt;
			if(xt1%spacing==0)
			{
				sprintf(number,"%d",xt1/S.point_space);
				x1=i+xc-strlen(number)*5/2-1;
				x2=x1+strlen(number)*5-2;
				if(x1>=xc&&x2<xc+xs)
					plot_font_h(WHITE,x1,yc+5,number,3,Font);
			}
		}
	}
	else
	{
		while(i<640&&i<xs-1)
		{
			fi+=fdi;
			i=fi;
			xt=S.first_point+(t++);
			xt1=xt;
			if(xt1%spacing==0)
			{
				sprintf(number,"%d",xt1/S.point_space);
				x1=i+xc-strlen(number)*5/2-1;
				x2=x1+strlen(number)*5-2;
				if(x1>=xc&&x2<xc+xs)
					plot_font_h(WHITE,x1,yc+5,number,3,Font);
			}
		}
	}
}


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

int load_pass(char *string,int pass[256][2])

{
	int i,j,k;
	FILE *fp;
	int input[4],maxpass=-1;

	for(i=0;i<256;i++)
	{
		pass[i][0]=0;
		pass[i][1]=0;
	}

	fp=fopen(string,"r+t");
	if(!fp)return(maxpass);

	while(fscanf(fp,"%d%d%d%d",input,input+3,input+1,input+2)==4)
	{
		for(i=input[1];i<=input[2];i++)
		{
			pass[i][0]=input[0];
			pass[i][1]=input[3];
		}
		if(input[0]>maxpass)maxpass=input[0];
	}
	if(fp)
		fclose(fp);
	return(maxpass);
}