/*
	vklein.c

	vkln.bat = cl /AL vklein.c vimage2 graphlib

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

#define MAX_BUFF 32768
#define MENU 12
#define MENU_C 7
#define MENU_X 3 
#define MENUXC 550
#define DEG_RAD 0.01745329251				/* converts degrees to radians */
#define INT1 64
#define INT2 255
#define HUE1 200
#define HUE2   0
#define SAT1 255
#define SAT2 255
#define   CYAN 0+Num_Color/2
#define YELLOW 3+Num_Color/2
#define    RED 2+Num_Color/2
#define ORANGE 1+Num_Color/2
#define  GREEN 4+Num_Color/2
#define   BLUE 5+Num_Color/2
#define D_BLUE 6+Num_Color/2
#define  BROWN 7+Num_Color/2
#define MAX_PIC  170
#define MAX_TEXT   5
#define S_SIZE 40

struct board
{
	int row,col,color;
}B_Id;
int Max_X,Min_X,Max_Y,Min_Y;
int Picture=0;
struct file_id
{
	char name[S_SIZE];
	long size;
	unsigned date,time;
};
extern struct file_id GF_File[8];
int Num_Vector=-1;
int Record_Bytes,File_Records;
int Row,Col;
int Row_Col_Header=0;
int Imbedded_Header=0;
int Sample_Bits=0;
char Image[100],Lut[100],Pal_Type,Label[100],Color_Image;
char FileName[8][60];
struct picture
{
	float lat,lon;
	char text[MAX_TEXT][60];
	char filename[60];
	int num_line;
}Pic[MAX_PIC];
float MaxLat,MinLat,MaxLon,MinLon;
int Bands=1; 
long Dir[3][2]={INT1,INT2,HUE1,HUE2,SAT1,SAT2};
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}
};
char *menu_v[8];
char *menu[MENU]= 
	{"zoom","graticule","reverse grey","fix track lines",
		"color","histogram","text plot","location",
		"vector plot","pictures of bottom",
		"Lable vectors",
		"exit"}; 
char *menu_c[MENU_C]=
	{"intensity","hue","saturation","bands of color","flip all",
		"reset","exit color"};
char *menu_x[MENU_X]= 
	{"new cross section","add cross section","exit"}; 
int Map=0,Zoom=0;
char Proj;
double LatB[2],LonB[2];
char InFile[100];
char VideoType='X',ImageSuffix[10],ImageScale=0,GreyScale=1,Scale;
int Num_Color=256;
int Sample,I_Sample;
int ScreenXs=640,ScreenYs=480,Reverse=0;
int SplitXc=0,SplitXs=320,SplitYc=0,SplitYs=480;
int PicXc=320,PicXs=320,PicYc=480,PicYs=480;
int ImageRow,ImageCol;
int Black=0,White=255,L_Grey=191,D_Grey=46,Center=127;
long Hist[256];
char Text[5][200];
int Color_Lines=0;
struct   Color 
{ 
	unsigned char  r, g, b; 
}lut[256],lutm[256],lutc[256],luts[256]; 
unsigned char Vga_Color[256];
unsigned char Mbuff[MAX_BUFF],Buffer[4096],Ibuff[MAX_BUFF];
unsigned char Inbuff[BUFSIZ],Inbuff2[BUFSIZ],Outbuff[BUFSIZ];
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
};

FILE *FpErr;

unsigned char getpt();
int set_lut();
char get_pad_color(long [2],int *);

main(argc,argv)

int argc;
char *argv[];

{
	int i,j,k,n;
	char string[100],imgfile[100],ans,ans2;
	int numfile,num=0,xnum=0,xc=0,yc=0,xs,ys,sample=1,scale=1,speed=16;
	int bxc=ScreenXs-257,byc=ScreenYs-129,bxs=256,bys=128;
	int wxc=0,wyc=0,wxs=380,wys=ScreenYs;
	int ix,iy,isize=20,ixo,iyo,num_text,picnum,hit;
	FILE *fp,*fpmap;
	int txc=ScreenXs/2,tyc=ScreenYs/2,txs=64,tys=ScreenYs/2,tspeed=16;
	double alpha=0.0,dxc0,dyc0,x,y,lat,lon;
	int numpic,color_on,val;

FpErr=fopen("vklein.err","wt");

	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';
		}
	}

fprintf(FpErr,"VideoType = '%c'",VideoType);
flushall();

	numfile=get_file_name("*.kln",InFile);
	strcpy(string,InFile);
	for(j=0;j<strlen(InFile);j++)
		if(string[j]=='.')
			string[j]='\0';
	strcat(string,".loc");
	fpmap=fopen(string,"rb");
	if(fpmap)
	{
		fscanf(fpmap,"%c",&Proj);
		while(fgetc(fpmap)!=0xa);
		if(Proj=='o')
		{
			fscanf(fpmap,"%lf",LatB);
			while(fgetc(fpmap)!=0xa);
			fscanf(fpmap,"%lf",LatB+1);
			while(fgetc(fpmap)!=0xa);
			fscanf(fpmap,"%lf",LonB);
			while(fgetc(fpmap)!=0xa);
			fscanf(fpmap,"%lf",LonB+1);
			fclose(fpmap);
			Map=1;
		}

fprintf(FpErr,"Map=%d  LonB[1]= %lf",Map,LonB[1]);
flushall();

	}
	else
	{
		printf("Could not find '%s'\n\n",string);
		exit(0);
	}
	i=GetVideoBoardID();

fprintf(FpErr,"i = %d\n",i);
flushall();

	set_video_on();
	if(VideoType=='E')
	{
		tyc=ScreenYs/2;
		tys=ScreenYs-1;
	}
	set_lut('g');

fprintf(FpErr,"back from set_lut()");
flushall();

	if(numfile>=0)
	{
		for(k=0;k<strlen(InFile);k++)
		if(InFile[k]=='.')
			InFile[k]='\0';
		strcpy(string,InFile);
		strcat(string,".lb");		
		fp=fopen(string,"rb");
		if(fp)
		{
			fscanf(fp,"%d",&ImageRow);
			while(fgetc(fp)!=0xa);
			fscanf(fp,"%d",&ImageCol);
			plot_full_image(1);
		}
		else
		{
			SetVideoMode(0);
			printf("Could not find '%s'\n\n",string);
			exit(0);
		}
		set_max_min(0,ImageCol,0,ImageRow);

		do
		{
			num=do_menu_buff(menu,MENU,MENUXC,25,num,141,200,White,Font);
			if(num==0)
			{
				Picture=0;
				scale=1;
				Max_X=xs=ScreenXs;
				ys=ScreenYs;
				if(Color_Lines==1)
					set_lut('g');
				paint_box(3,D_Grey,Mbuff,0,0,ScreenXs,ScreenYs);
				strcpy(imgfile,InFile);
				strcat(imgfile,".kln");
				Sample=(ImageCol+ScreenXs-1)/ScreenXs;
				sample=(ImageRow+ScreenYs-1)/ScreenYs;
				if(sample>Sample)
					Sample=sample;
				plot_full_image(1);
				if(limit_area_fixed(&xc,&yc,&xs,&ys,&speed,&scale,0,Sample,1)!=27)
				{
					expand(imgfile,Mbuff,scale,xc,yc,0);
					Zoom=1;
					set_max_min(xc,xc+ScreenXs*scale,yc,yc+ScreenYs*scale);
				}
				else
					Zoom=0;
			}
			if(num==1&&Map==1)	/* graticule */
			{
				if(Zoom==0)
				{
					Sample=(ImageCol+ScreenXs-1)/ScreenXs;
					sample=(ImageRow+ScreenYs-1)/ScreenYs;
					if(sample>Sample)
						Sample=sample;
					grat(0,0,Sample);
				}
				else
				{
					grat(xc,yc,scale);
				}
			}
			if(num==2)		/* reverse grey scale */
			{
				if(Reverse==0)
					Reverse=1;
				else
					Reverse=0;
				set_lut('g');
			}
			if(num==3)
				fix_tip(&txc,&tyc,&txs,&tys,&tspeed,&alpha);
			if(num==4)	/* color */
			{
				color_table(ScreenXs-155,ScreenYs-20,150,15); 
			}
			if(num==5)	/* Histogram */
			{
				sprintf(string,"Size and Place graph on screen");
				xc=yc=5;
				ys=20;xs=(strlen(string)+2)*7;
				save_sub_mem(xc,yc,xs,ys);
				paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
				plot_font_h(White,xc+7,yc+4,string,2,Font);
				limit_area_all(&bxc,&byc,&bxs,&bys,&speed,ScreenXs,ScreenYs,
					1,Buffer,Black,White,Center,1);
				paint_box(0,Black,Buffer,bxc,byc,bxs,bys);
				box(0,bxc,byc,D_Grey,bxs-1,bys-1);
				recall_sub_mem(xc,yc,xs,ys);
				do
				{
sprintf(string,
"Limit area to process for Histogram  ('Del' to Process  'Esc' to exit)");
					xc=yc=0;
					ys=20;xs=(strlen(string)+2)*7;
					save_sub_mem(xc,yc,xs,ys);
					paint_box(0,D_Grey,Buffer,xc,yc,xs,ys);
					plot_font_h(White,xc+7,yc+4,string,2,Font);
					ans=limit_area_all(&wxc,&wyc,&wxs,&wys,&speed,ScreenXs,ScreenYs,
						1,Buffer,Black,White,Center,1);
					recall_sub_mem(xc,yc,xs,ys);
					if(ans!=27)
					{
						paint_box(0,Black,Buffer,bxc,byc,bxs,bys);
						box(0,bxc,byc,D_Grey,bxs-1,bys-1);
						histo(wxc,wyc,wxs,wys,bxc,byc,bxs,bys,White);
					}
				}while(ans!=27);			
				paint_box(0,Black,Buffer,bxc,byc,bxs,bys);
			}
			if(num==6)  /* plot text */
			{
				if(Zoom==0)
				{
					Sample=(ImageCol+ScreenXs-1)/ScreenXs;
					sample=(ImageRow+ScreenYs-1)/ScreenYs;
					if(sample>Sample)
						Sample=sample;
					xc=yc=0;
					scale=Sample;
					hit=plot_text(0,0,Sample);
				}
				else
				{
					hit=plot_text(xc,yc,scale);
				}
				if(hit>0)
				{
					ixo=ix=ScreenXs/2;
					iyo=iy=ScreenYs/2;
					speed=16;
					tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,(Num_Color*3)/4);
					do
					{
						ans2=getpad(&isize,&ix,&iy,&speed);
						if(ans2==13)
						{
							num_text=find_text(xc,yc,scale,&ix,&iy,Text);
							paint_box(0,0,Buffer,0,ScreenYs-num_text*20,
								ScreenXs,num_text*20);
							for(k=0;k<num_text;k++)
								plot_font_h(Num_Color-1,5,ScreenYs-num_text*20+k*20,
									Text[k],2,Font);
						}
						uncursor(0,ixo,iyo,isize,Buffer);
						tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,
								(Num_Color*3)/4);
						ixo=ix;
						iyo=iy;
					}while(ans2!='x'&&ans2!=27);
					uncursor(0,ixo,iyo,isize,Buffer);
				}
				paint_box(0,0,Buffer,0,ScreenYs-num_text*20,
					ScreenXs,num_text*20);
			}
			if(num==7)	/* position */
			{
				Sample=(ImageCol+ScreenXs-1)/ScreenXs;
				sample=(ImageRow+ScreenYs-1)/ScreenYs;
				if(sample>Sample)
					Sample=sample;
				if(Zoom==0)
				{
					xc=yc=0;
					scale=Sample;
				}
				ixo=ix=ScreenXs/2;
				iyo=iy=ScreenYs/2;
				dxc0=xc*Sample;
				dyc0=yc*Sample;
				speed=16;
				tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,(Num_Color*3)/4);
				ixo=ix;
				iyo=iy;
				x=dxc0+ix*scale;
				y=dyc0+iy*scale;
				o_xy_ll(x,y,&lat,&lon);
				paint_box(0,0,Buffer,0,ScreenYs-20,
					ScreenXs,20);
				sprintf(Text[0],"Latitude = %lf  Longitude = %lf dn = %d",
					lat,lon,val);
				plot_font_h(Num_Color-1,5,ScreenYs-20,Text[0],2,Font);
				do
				{
					ans2=getpad(&isize,&ix,&iy,&speed);
					uncursor(0,ixo,iyo,isize,Buffer);
					val=getpt(0,ix,iy);
					tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,
							(Num_Color*3)/4);
					ixo=ix;
					iyo=iy;
					x=dxc0+ix*scale;
					y=dyc0+iy*scale;
					o_xy_ll(x,y,&lat,&lon);
					paint_box(0,0,Buffer,0,ScreenYs-20,
						ScreenXs,20);
					sprintf(Text[0],"Latitude = %lf  Longitude = %lf dn = %d",
						lat,lon,val);
					plot_font_h(Num_Color-1,5,ScreenYs-20,Text[0],2,Font);

				}while(ans2!='x'&&ans2!=27);
				uncursor(0,ixo,iyo,isize,Buffer);
				paint_box(0,0,Buffer,0,ScreenYs-20,
					ScreenXs,20);
			}
			if(num==8)
			{
				Sample=(ImageCol+ScreenXs-1)/ScreenXs;
				sample=(ImageRow+ScreenYs-1)/ScreenYs;
				if(sample>Sample)
					Sample=sample;
				if(Zoom==0)
				{
					xc=yc=0;
					scale=Sample;
				}
				Max_X=ScreenXs;
				val=get_vector(string,xc,yc,scale);
				if(Picture==1)
					Max_X*=2;
			}
			if(num==9)  /* Pictures of bottom */
			{
				Picture=1;
				scale=1;
				SetVideoMode(0);
				numpic=load_pic();				
				set_video_on();
				set_lut('g');
				paint_box(3,D_Grey,Mbuff,0,0,ScreenXs,ScreenYs);
				ScreenXs/=2;
				xs=ScreenXs;
				ys=ScreenYs;
				strcpy(imgfile,InFile);
				strcat(imgfile,".kln");
				Sample=(ImageCol+ScreenXs-1)/ScreenXs;
				sample=(ImageRow+ScreenYs-1)/ScreenYs;
				if(sample>Sample)
					Sample=sample;
				plot_full_image(2);
				plot_pic_loc(0,0,Sample,numpic);
				if(limit_area_fixed(&xc,&yc,&xs,&ys,&speed,&scale,0,Sample,1)!=27)
				{
					expand(imgfile,Mbuff,scale,xc,yc,0);
					Zoom=1;
					set_max_min(xc,xc+ScreenXs*scale,yc,yc+ScreenYs*scale);
				}
				else
				{
					xc=yc=0;
					scale=Sample;
					Zoom=0;
				}
				hit=plot_pic_loc(xc,yc,scale,numpic);
				if(hit>0)
				{
					ixo=ix=ScreenXs/2;
					iyo=iy=ScreenYs/2;
					speed=16;
					tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,(Num_Color*3)/4);
					do
					{
						ans2=getpad(&isize,&ix,&iy,&speed);
						if(ans2==13)
						{
							n=find_pic(xc,yc,scale,&ix,&iy,numpic);
							uncursor(0,ixo,iyo,isize,Buffer);
							tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,
								(Num_Color*3)/4);
							ixo=ix;
							iyo=iy;
							ScreenXs*=2;
							paint_box(0,0,Buffer,ScreenXs,0,ScreenXs/2,ScreenYs);
							ScreenXs/=2;
							plot_picture(Pic[n].filename);
							ScreenXs*=2;
							paint_box(0,0,Buffer,ScreenXs/2,
								ScreenYs-Pic[n].num_line*20,ScreenXs/2,
								Pic[n].num_line*20);
							for(k=0;k<Pic[n].num_line;k++)
								plot_font_h(Num_Color-1,ScreenXs/2+5,
									ScreenYs-Pic[n].num_line*20+k*20,
									Pic[n].text[k],2,Font);
							ScreenXs/=2;
							color_on=1;
							do
							{
								ans=getch();
								if(ans=='c'||ans=='g')
								{
									if(color_on==1)
									{
										set_lut('g');
										color_on=0;
									}
									else
									{
										WritePalette(lutc);
										color_on=1;
									}
								}
							}while(ans!=13&&ans!=27&&ans!=82&&ans!=83&&
									ans!=71&&ans!=72&&ans!=73&&
									ans!=75&&ans!=77&&
									ans!=79&&ans!=80&&ans!=81);
							set_lut('g');
						}
						uncursor(0,ixo,iyo,isize,Buffer);
						tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,
								(Num_Color*3)/4);
						ixo=ix;
						iyo=iy;
					}while(ans2!='x'&&ans2!=27);
					uncursor(0,ixo,iyo,isize,Buffer);
				}
				SetVideoMode(0);
				set_video_on();
				set_lut('g');
			}
			if(num==10)
			{
				Sample=(ImageCol+ScreenXs-1)/ScreenXs;
				sample=(ImageRow+ScreenYs-1)/ScreenYs;
				if(sample>Sample)
					Sample=sample;
				if(Zoom==0)
				{
					xc=yc=0;
					scale=Sample;
				}
				Max_X=ScreenXs;
				val=label_vector(string,xc,yc,scale);
				if(Picture==1)
					Max_X*=2;
			}
		}while(num<MENU-1);
	}
	SetVideoMode(0);
}


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

int label_vector(vector,xc,yc,scale)

char *vector;
int xc,yc,scale;

{
	int i,j,k;
	char string[60],ans;
	int numfile,num=0,sample,txt_size=2;
	double dxc0=xc*Sample,dyc0=yc*Sample;
	double x,y,lat,lon,dscale=scale,dlat,dlon;
	float lat0,lon0,lat1,lon1,dist,mindist,lonscale;
	int ix,iy,ixo,iyo,speed,isize=5,numseg,numpt,px,py,len;
	FILE *fpbin,*fpatr,*fphdr;
	long attrib,attrib_c;
	float latlon[2],mll[4],mnln,mxln,mnlt,mxlt;

	if(Num_Vector<=0)
		return(-1);
	numfile=Num_Vector;
	strcpy(FileName[numfile],"exit Label");
	for(k=0;k<=numfile;k++)
		menu_v[k]=FileName[k];
	do
	{
		num=do_menu_buff(menu_v,numfile+1,30,25,num,141,200,White,Font);
		if(num<numfile)
		{
			strcpy(string,FileName[num]);
			strcat(string,".atr");
			fpatr=fopen(string,"rb");
			if(!fpatr)
			{
				SetVideoMode(0);
				printf("Could not open '%s'\n",string);
				exit(0);
				return(-2);		/* no attribute file */
			}
			strcpy(string,FileName[num]);
			strcat(string,".bin");
			fpbin=fopen(string,"rb");
			if(!fpbin)
			{
				SetVideoMode(0);
				printf("Could not open '%s'\n",string);
				exit(0);
				return(-3);		/* no bin file */
			}
			Sample=(ImageCol+ScreenXs-1)/ScreenXs;
			sample=(ImageRow+ScreenYs-1)/ScreenYs;
			if(sample>Sample)
				Sample=sample;
			if(Zoom==0)
			{				xc=yc=0;
				scale=Sample;
			}
			ixo=ix=ScreenXs/2;
			iyo=iy=ScreenYs/2;
			speed=16;
			tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,(Num_Color*3)/4);
			ixo=ix;
			iyo=iy;
			do
			{
				ans=getpad(&isize,&ix,&iy,&speed);
				uncursor(0,ixo,iyo,isize,Buffer);
				tcursor_val(0,ix,iy,isize,Buffer,0,Num_Color-1,
						(Num_Color*3)/4);
				ixo=ix;
				iyo=iy;
				if(ans=='s')
					if(txt_size<4)
						txt_size+=1;
				if(ans=='l')
					if(txt_size>1)
						txt_size-=1;
				py=19/txt_size;
				py/=2;
				if(ans==13)
				{
					rewind(fpbin);
					rewind(fpatr);
					x=dxc0+ix*scale;
					y=dyc0+iy*scale;
					o_xy_ll(x,y,&lat,&lon);
					lonscale=1.0/cos(lat*DEG_RAD);
					lat0=lat;lon0=lon;
					fread((char *)&numseg,sizeof(int),1,fpbin);
					mindist=100000000.0;
					for(i=0;i<numseg;i++)
					{
						fread((char *)&numpt,sizeof(int),1,fpbin);
						fread((char *)mll,sizeof(float),4,fpbin);
						fread((char *)&attrib,sizeof(long),1,fpatr);
						for(j=0;j<numpt;j++)
						{
							fread((char *)latlon,sizeof(float),2,fpbin);
							dist=(lat0-latlon[0])*(lat0-latlon[0])+
									(lon0-latlon[1])*(lon0-latlon[1]);
							if(dist<mindist)
							{
								attrib_c=attrib;
								mindist=dist;
							}
						}
					}
					sprintf(string,"%ld",attrib_c);
					len=strlen(string);
					px=len;
					px*=15/txt_size;
					px/=2;
					plot_font_h(num+Num_Color/2,ix-px,iy-py,string,txt_size,Font);
				}
			}while(ans!='x'&&ans!=27);
			uncursor(0,ixo,iyo,isize,Buffer);
			fclose(fpatr);
			fclose(fpbin);
		}
	}while(num<numfile);
	strcpy(vector,FileName[num]);
	return(num);
}



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

int get_vector(vector,xc,yc,scale)

char *vector;

{
	int i,j,k;
	char filename[60];
	int numfile,num=0,sample;

	Num_Vector=numfile=load_names("*.hdr");
	sort_name(numfile);
	for(k=0;k<numfile;k++)
	{
		strcpy(FileName[k],GF_File[k].name);
		for(j=0;j<strlen(FileName[k]);j++)
			if(FileName[k][j]=='.')
				FileName[k][j]='\0';
	}
	strcpy(FileName[numfile],"exit vector");
	for(k=0;k<=numfile;k++)
		menu_v[k]=FileName[k];
	do
	{
		num=do_menu_buff(menu_v,numfile+1,30,25,num,141,200,White,Font);
		Sample=(ImageCol+ScreenXs-1)/ScreenXs;
		sample=(ImageRow+ScreenYs-1)/ScreenYs;
		if(sample>Sample)
			Sample=sample;
		if(Zoom==0)
		{
			xc=yc=0;
			scale=Sample;
		}
		if(Color_Lines==0)
		{
			for(i=0;i<ScreenYs;i++)
			{
				getrow(0,0,ScreenXs-1,i,Buffer);
				for(j=0;j<ScreenXs;j++)
					Buffer[j]/=2;
				plotrow(0,0,ScreenXs-1,i,Buffer);
			}
				set_lut('d');
		}
		convert_bin(xc,yc,scale,FileName[num],num+Num_Color/2);
	}while(num<numfile);
	strcpy(vector,FileName[num]);
	return(num);
}


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

int plot_picture(filename)

char *filename;

{
	int i,j,k;
	char ans;

	if(read_lbl(filename)>0)
	{
		load_image(Image);
	}
}

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

int load_image(filename)

char *filename;

{
	int i,j,k;
	int row=Row,col=Col,sample=0;
	int xc=0,yc=0,xs,ys,speed=16;
	FILE *fp;
	long offset=0;
	char string[100];
	int sxs=ScreenXs,sys=ScreenYs;

	ScreenXs*=2;

	if(Sample_Bits==0)
		Sample_Bits=8;

	if((row==0||col==0)&&Row_Col_Header==0)
		return(-1);
	fcloseall();
	fp=fopen(filename,"rb");
	if(!fp)
		return(-1);
	do
	{
		I_Sample=sample+=1;
		row=Row/sample;
		col=Col/sample;
		offset=sample-1;
		offset*=Col;
	}while(col>ScreenXs/2||row>ScreenYs);
	if(set_lut('P',Lut)<0)
		set_lut('g');
	for(i=0;i<row;i++)
	{
		fread((char *)Mbuff,sizeof(char),Col,fp);
		fseek(fp,offset,SEEK_CUR);
		if(sample>1)
			for(j=0;j<col;j++)
				Mbuff[j]=Mbuff[j*sample];
		if(VideoType=='V'||VideoType=='E')
			for(j=0;j<col;j++)
				Mbuff[j]=Vga_Color[Mbuff[j]];
		plotrow(0,ScreenXs/2,ScreenXs/2+col-1,i,Mbuff);
	}
	if(sample>1)
	{
		sample=1;
		 if(limit_area_fixed(&xc,&yc,&xs,&ys,
				&speed,&sample,ScreenXs/2,I_Sample,2)!=27)
		{
			rewind(fp);
			paint_box(3,0,Mbuff,ScreenXs/2,0,ScreenXs/2,ScreenYs);
			offset=Col;
			offset*=yc*I_Sample;
			offset+=xc*I_Sample;
			if(Row_Col_Header>0)
				offset+=4;
			fseek(fp,offset,SEEK_SET);
			row=ScreenYs;
			col=ScreenXs/2;
			if((yc*I_Sample+row*sample)>Row)
				row=(Row-yc*I_Sample)/sample;
			if((xc*I_Sample+col*sample)>Col)
				col=(Col-xc*I_Sample)/sample;
			offset=Col;
			offset*=(sample-1);
			for(i=0;i<row;i++)
			{
				fread((char *)Mbuff,sizeof(char),Col,fp);
				fseek(fp,offset,SEEK_CUR);
				if(sample>1)
					for(j=0;j<col;j++)
						Mbuff[j]=Mbuff[j*sample];
				if(VideoType=='V'||VideoType=='E')
					for(j=0;j<col;j++)
						Mbuff[j]=Vga_Color[Mbuff[j]];
				plotrow(3,ScreenXs/2,ScreenXs/2+col-1,i,Mbuff);
			}
		}
	}
	fclose(fp);
	ScreenXs/=2;
}


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

int read_lbl(label)

char *label;

{
	int i,j,k;
	char string1[100],string2[100],string3[100];
	FILE *fp;
	int status=1,numread;

	fp=fopen(label,"rt");	
	if(!fp)
		return(-1);
	Sample_Bits=Record_Bytes=File_Records=Pal_Type=Row_Col_Header=0;
	while(fscanf(fp,"%s",string1)==1)
	{
		if(strcmpi(string1,"end")==0)
		{
			fclose(fp);
			return(status);
		}
		if(strcmpi(string1,"image_lines")==0&&File_Records==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			sscanf(string3,"%d",&Row);
		}
		if(strcmpi(string1,"sample_bits")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			sscanf(string3,"%d",&Sample_Bits);
		}
		if(strcmpi(string1,"file_records")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			sscanf(string3,"%d",&Row);
			File_Records=Row;
		}
		if(strcmpi(string1,"line_samples")==0&&Record_Bytes==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			sscanf(string3,"%d",&Col);
		}
		if(strcmpi(string1,"record_bytes")==0||
			strcmpi(string1,"image_record_bytes")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			sscanf(string3,"%d",&Col);
			Record_Bytes=Col;
		}
		if(strcmpi(string1,"image_pointer")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			k=0;
			for(i=0;i<strlen(string3);i++)
				if(string3[i]!=39)		/* single quote */
					Image[k++]=string3[i];
			Image[k]='\0';
		}
		if(strcmpi(string1,"pal_type")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			k=0;
			for(i=0;i<strlen(string3);i++)
				if(string3[i]!=39)		/* single quote */
					string1[k++]=string3[i];
			string1[k]='\0';
			Pal_Type=string1[0];
		}
		if(strcmpi(string1,"pal_pointer")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			k=0;
			for(i=0;i<strlen(string3);i++)
				if(string3[i]!=39)		/* single quote */
					Lut[k++]=string3[i];
			Lut[k]='\0';
		}
		if(strcmpi(string1,"row_col_header")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}			
			Row_Col_Header=1;
		}
	}
	fclose(fp);
	return(status);
}


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

int find_pic(xc,yc,scale,xx,yy,numpic)

int xc,yc,scale,*xx,*yy,numpic;

{
	int i,j,k;
	FILE *fp;
	double dxc0=xc*Sample,dyc0=yc*Sample,dsample=Sample,dscale=scale;
	int num_line=-1,eof=0;
	double lat,lon,x,y,min=500000000000000000000.0,dx=*xx,dy=*yy,dist;
	int ix,iy;

	for(i=0;i<numpic;i++)
	{
		o_ll_xy(&x,&y,(double)Pic[i].lat,(double)Pic[i].lon);
		ix=(x-dxc0)/dscale;
		iy=(y-dyc0)/dscale;
		x=ix;y=iy;
		dist=(x-dx)*(x-dx)+(y-dy)*(y-dy);
		if(dist<min&&ix>=0&&ix<ScreenXs&&iy>=0&&iy<ScreenYs)
		{
			num_line=i;
			*xx=ix;
			*yy=iy;
			min=dist;
		}
	}
	return(num_line);
}

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

int plot_pic_loc(xc,yc,scale,numpic)

int xc,yc,scale,numpic;

{
	int i,j,k;
	double dxc0=xc*Sample,dyc0=yc*Sample,dsample=Sample,dscale=scale;
	int num_line,eof=0;
	double lat,lon,x,y;
	int ix,iy,hits=0;

	for(i=0;i<numpic;i++)
	{
		o_ll_xy(&x,&y,(double)Pic[i].lat,(double)Pic[i].lon);
		ix=(x-dxc0)/dscale;
		iy=(y-dyc0)/dscale;
		if(ix>=0&&ix<ScreenXs&&iy>=0&&iy<ScreenYs)
		{
			tcursor_val(0,ix,iy,5,Buffer,0,Num_Color-1,(Num_Color*4)/3);
			hits+=1;
		}
	}
	return(hits);
}


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

int load_pic()

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

	strcpy(string,InFile);
	strcat(string,".pic");
	fp=fopen(string,"rb");
	if(fp)
	{
		i=0;
		while(fscanf(fp,"%f%f%s",&Pic[i].lat,&Pic[i].lon,Pic[i].filename)==3)
		{
			while(fgetc(fp)!=0xa);
			j=0;
			do
			{
				k=0;
				while((Pic[i].text[j][k++]=fgetc(fp))!=0xa&&k<60);
				Pic[i].text[j][k-2]='\0';
				j+=1;
			}while(Pic[i].text[j-1][0]!='*');
			Pic[i].num_line=j-1;
			i+=1;
		}
		fclose(fp);
		return(i);
	}
}






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

int set_video_on()

{
	int i,j,k;

	i=GetVideoBoardID();
	if(i==0)
		VideoType='E';
	else if(i==1&&(VideoType=='X'||VideoType=='Y'))
		VideoType='V';
	if(VideoType=='V')
	{
		SetVideoMode(0x12,&B_Id);
		ScreenXs=640;
		ScreenYs=480;
		strcpy(ImageSuffix,".vmg");
		GreyScale=16;
		Center=7;
		Num_Color=16;
	}
	if(VideoType=='E')
	{
		SetVideoMode(0x10,&B_Id);
		ScreenXs=640;
		SplitYs=PicYs=ScreenYs=350;
		strcpy(ImageSuffix,".emg");
		GreyScale=16;
		Center=7;
		Num_Color=16;
	}
	if(VideoType=='X')
	{
		SetVideoMode(480,&B_Id);
		ScreenXs=640;
		ScreenYs=480;
		strcpy(ImageSuffix,".xmg");
		Num_Color=256;
	}
}







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

int convert_bin(xc,yc,scale,region,val)

int xc,yc,scale;
char *region;
int val;

{
	int i,j,k;
	double x,y,xo,yo;
	int ix,iy,ixo=-1,iyo=-1;
	double dx,dy,dist;
	int secnum,numpt,numsec;
	FILE *fp,*fphdr;
	float latlon[2],mll[4],mnln,mxln,mnlt,mxlt;
	char string[40];
	int doit,numplot=0;
	int first_seg=-1,last_seg=-1;
	long offset;
	double dxc0=xc*Sample,dyc0=yc*Sample,dsample=Sample,dscale=scale;

	strcpy(string,region);
	strcat(string,".bin");
	fp=fopen(string,"rb");
	if(!fp)return(-1);
	setbuf(fp,Inbuff);
	strcpy(string,region);
	strcat(string,".hdr");
	fphdr=fopen(string,"rb");
	if(!fphdr)
		return(-1);
	setbuf(fphdr,Inbuff2);

	fread((char *)&numsec,sizeof(int),1,fphdr);
	fread((char *)&numsec,sizeof(int),1,fp);

	for(j=0;j<numsec;j++)
	{
		fread((char *)&offset,sizeof(long),1,fphdr);
		fread((char *)mll,sizeof(float),4,fphdr);
		doit=1;
		mnln=mll[0];mxln=mll[1];mnlt=mll[2];mxlt=mll[3];
/*		if(mnln>MaxLon||mnlt>MaxLat||mxln<MinLon||mxlt<MinLat)
		{
			doit=0;
		}

FpErr=fopen("vklein.err","at");
fprintf(FpErr,"doit = %d\n",doit);
fprintf(FpErr,"MinLat=%10.6f MaxLat=%10.6f   MinLon=%10.6f MaxLon=%10.6f\n",
MinLat,MaxLat,MinLon,MaxLon);
fprintf(FpErr,"  mnlt=%10.6f   mxlt=%10.6f     mnln=%10.6f   mxln=%10.6f\n",
mnlt,mxlt,mnln,mxln);
fclose(FpErr);
*/
		if(doit==1)
		{
			numplot+=1;
			fseek(fp,offset,SEEK_SET);
			fread((char *)&numpt,sizeof(int),1,fp);
			fread((char *)mll,sizeof(float),4,fp);

			for(i=0;i<numpt;i++)
			{
				fread((char *)latlon,sizeof(float),2,fp);
				if(doit==1)
				{
					o_ll_xy(&x,&y,(double)latlon[0],(double)latlon[1]);
					if(i==0)
					{
						xo=x;yo=y;
						ixo=ix;iyo=iy;
					}
					ix=(x-dxc0)/dscale;
					iy=(y-dyc0)/dscale;
					if(i>0)
						plotln(3,ix,iy,ixo,iyo,val);
					ixo=ix;iyo=iy;
					xo=ix;yo=iy;
				}
			}
		}
	}
	fclose(fp);
	fclose(fphdr);
	return(numplot);
}


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

int set_max_min(ix1,ix2,iy1,iy2)

int ix1,ix2,iy1,iy2;

{
	int i,j,k;
	double x,y,lat,lon;

	x=ix2;
	y=iy1;
	o_xy_ll(x,y,&lat,&lon);
	MaxLat=lat;
	MaxLon=lon;
	x=ix1;
	y=iy2;
	o_xy_ll(x,y,&lat,&lon);
	MinLat=lat;
	MinLon=lon;
}

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

int convert_bin_val(xc,yc,scale,region,low,high,center)

int xc,yc,scale;
char *region;
int low,high,center;

{
	int i,j,k;
	double x,y,xo,yo;
	int ix,iy,ixo=-1,iyo=-1;
	double dx,dy,dist;
	int secnum,numpt,numsec;
	FILE *fp,*fphdr;
	float latlon[2],mll[4],mnln,mxln,mnlt,mxlt;
	char string[40];
	int doit,numplot=0;
	int first_seg=-1,last_seg=-1;
	long offset;
	double dxc0=xc*Sample,dyc0=yc*Sample,dsample=Sample,dscale=scale;
	int val;

	strcpy(string,region);
	strcat(string,".bin");
	fp=fopen(string,"rb");
	if(!fp)return(-1);
	setbuf(fp,Inbuff);
	strcpy(string,region);
	strcat(string,".hdr");
	fphdr=fopen(string,"rb");
	if(!fphdr)
		return(-1);
	setbuf(fphdr,Inbuff2);

	fread((char *)&numsec,sizeof(int),1,fphdr);
	fread((char *)&numsec,sizeof(int),1,fp);

	for(j=0;j<numsec;j++)
	{
		fread((char *)&offset,sizeof(long),1,fphdr);
		fread((char *)mll,sizeof(float),4,fphdr);
		doit=1;
		mnln=mll[0];mxln=mll[1];mnlt=mll[2];mxlt=mll[3];
		if(mnln>MaxLon||mnlt>MaxLat||mxln<MinLon||mxlt<MinLat)
		{
			doit=0;
		}
		if(doit==1)
		{
			numplot+=1;
			fseek(fp,offset,SEEK_SET);
			fread((char *)&numpt,sizeof(int),1,fp);
			fread((char *)mll,sizeof(float),4,fp);

			for(i=0;i<numpt;i++)
			{
				fread((char *)latlon,sizeof(float),2,fp);
				if(doit==1)
				{
					o_ll_xy(&x,&y,(double)latlon[0],(double)latlon[1]);
					if(i==0)
					{
						xo=x;yo=y;
						ixo=ix;iyo=iy;
					}
					dx=ix=(x-dxc0)/dscale;
					dy=iy=(y-dyc0)/dscale;
					val=high;
					if(i>0)
					{
						dx-=ixo;
						dy-=iyo;
						dist=dx*dx+dy*dy;
						if(dist<40000.0)
						{
							plotln_val(3,ix,iy,ixo,iyo,Black,White,L_Grey,1);
							ixo=ix;iyo=iy;
							xo=ix;yo=iy;
						}
					}
				}
			}
		}
	}
	fclose(fp);
	fclose(fphdr);
	return(numplot);
}



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

int find_text(xc,yc,scale,xx,yy,text)

int xc,yc,scale,*xx,*yy;
char text[5][200];

{
	int i,j,k;
	FILE *fp;
	double dxc0=xc*Sample,dyc0=yc*Sample,dsample=Sample,dscale=scale;
	int num_line,eof=0;
	double lat,lon,x,y,min=500000000000000000000.0,dx=*xx,dy=*yy,dist;
	int ix,iy;
	char string[5][100];

	strcpy(string[0],InFile);
	strcat(string[0],".txt");		
	fp=fopen(string[0],"rb");
	if(!fp)
		return(-1);
	k=0;
	while((string[0][k++]=fgetc(fp))!=0xa);
	sscanf(string[0],"%d",&num_line);

	do
	{
		k=0;
		while((string[0][k]=fgetc(fp))!=0xa&&string[0][k]!=EOF)
		{
			k+=1;
		}
		if(k<2)
			eof=1;
		else
		{
			sscanf(string[0],"%lf%lf",&lat,&lon);
			for(i=0;i<num_line;i++)
			{
				k=0;
				while((string[i][k]=fgetc(fp))!=0xa)
					k+=1;
				string[i][k+1]='\0';
			}
			o_ll_xy(&x,&y,lat,lon);
			ix=(x-dxc0)/dscale;
			iy=(y-dyc0)/dscale;
			x=ix;y=iy;
			dist=(x-dx)*(x-dx)+(y-dy)*(y-dy);
			if(dist<min&&ix>=0&&ix<ScreenXs&&iy>=0&&iy<ScreenYs)
			{
				for(i=0;i<num_line;i++)
					for(k=0;k<100;k++)
					{
						text[i][k]=string[i][k];
						if(text[i][k]==13)
							text[i][k]='\0';
					}
				*xx=ix;
				*yy=iy;
				min=dist;
			}
		}
	}while(eof==0);
	fclose(fp);
	return(num_line);
}

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

int plot_text(xc,yc,scale)

int xc,yc,scale;

{
	int i,j,k;
	FILE *fp;
	double dxc0=xc*Sample,dyc0=yc*Sample,dsample=Sample,dscale=scale;
	int num_line,eof=0;
	double lat,lon,x,y;
	int ix,iy,hits=0;
	char string[100];

	strcpy(string,InFile);
	strcat(string,".txt");		
	fp=fopen(string,"rb");
	if(!fp)
		return(-1);
	k=0;
	while((Text[0][k++]=fgetc(fp))!=0xa);
	sscanf(Text[0],"%d",&num_line);

	do
	{
		k=0;
		while((Text[0][k]=fgetc(fp))!=0xa&&Text[0][k]!=EOF)
		{
			k+=1;
		}
		if(k<2)
			eof=1;
		else
		{
			sscanf(Text[0],"%lf%lf",&lat,&lon);
			for(i=0;i<num_line;i++)
			{
				k=0;
				while((Text[i][k]=fgetc(fp))!=0xa)
				{
					k+=1;
				}
			}
			o_ll_xy(&x,&y,lat,lon);
			ix=(x-dxc0)/dscale;
			iy=(y-dyc0)/dscale;
			if(ix>=0&&ix<ScreenXs&&iy>=0&&iy<ScreenYs)
			{
				tcursor_val(0,ix,iy,5,Buffer,0,Num_Color-1,(Num_Color*4)/3);
				hits+=1;
			}
		}
	}while(eof==0);
	fclose(fp);
	return(hits);
}

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

int grat(xc,yc,scale)

int xc,yc,scale;

{
	int i,j,k;
	double dxc0=xc*Sample,dyc0=yc*Sample,dsample=Sample,dscale=scale;
	double x,y,lat,lon,lon1,lat1,lon2,lat2,del,dspace;
	int ilat1,ilon1,space=30;
	long llatsec1,llonsec1,llatsec2,llonsec2;
	long li,lj,lk,ldeg,lmin,lsec;
	int ix,iy;
	char string[100];

	if(scale<8)space=10;
	if(scale<4)space=5;
	dspace=space;

	del=1.0/3600;
	x=dxc0;
	y=dyc0;
	o_xy_ll(x,y,&lat1,&lon1);
	ilat1=lat1;
	ilon1=lon1;
	llatsec1=lat1*3600/space;
	llonsec1=lon1*3600/space;
	x=dxc0+ScreenXs*scale;
	y=dyc0+ScreenYs*scale;
	o_xy_ll(x,y,&lat2,&lon2);
	llatsec2=lat2*3600/space;
	llonsec2=lon2*3600/space;

	for(li=llonsec1;li<=llonsec2;li+=1)
	{
		lat=0.0;
		lon=li;
		lon-=0.1/dspace;
		lon/=3600.0/dspace;
		o_ll_xy(&x,&y,lat,lon);
		ix=(x-dxc0)/dscale;
		plotln(3,ix,0,ix,ScreenYs-1,D_Grey);
		ldeg=-lon;
		lmin=-lon*60;
		lmin%=60;
		lsec=-lon*3600;
		lsec%=60;
		sprintf(string,"-%ld`%2ld'%2ld\"",ldeg,lmin,lsec);
		plot_font_v(White,ix-3,ScreenYs-5,string,3,Font);
	}
	for(li=llatsec2;li<=llatsec1;li+=1)
	{
		lon=0.0;
		lat=li;
		lat+=0.1/dspace;
		lat/=3600.0/dspace;
		o_ll_xy(&x,&y,lat,lon);
		iy=(y-dyc0)/dscale;
		plotln(3,0,iy,ScreenXs-1,iy,D_Grey);
		ldeg=lat;
		lmin=lat*60;
		lmin%=60;
		lsec=lat*3600;
		lsec%=60;
		sprintf(string,"%ld`%2ld'%2ld\"",ldeg,lmin,lsec);
		plot_font_h(White,3,iy-3,string,3,Font);
	}
}


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

int histo(xc,yc,xs,ys,bxc,byc,bxs,bys,val)

int xc,yc,xs,ys,bxc,byc,bxs,bys,val;

{
	int i,j,k,x,y;
	int max=0,ival;
	float fval;

	for(k=0;k<Num_Color;k++)
		Hist[k]=0;
	for(i=1;i<ys;i++)
	{
		getrow(3,xc+1,xc+xs-1,i+yc,Buffer);
		for(j=0;j<xs-2;j++)
			Hist[Buffer[j]]+=1;
	}
	for(k=0;k<Num_Color;k++)
		if(Hist[k]>max)
			max=Hist[k];
	for(k=0;k<Num_Color;k++)
	{
		fval=Hist[k];
		fval*=bys;
		fval/=(float)max;
		y=fval;
		fval=k;
		fval*=bxs;
		fval/=(float)Num_Color;
		x=fval;
		plotln(0,bxc+x,byc+bys-y,bxc+x,byc+bys,val);
	}
}


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

int color_table(xc,yc,xs,ys)

int xc,yc,xs,ys;

{
	int i,j,k;
	int val,speed=16;
	long lval;
	char ans,num=0;

	for(j=0;j<xs;j++)
	{
		lval=j;
		lval*=Num_Color;
		lval/=xs;
		val=lval+1;
		for(i=0;i<ys;i++)
			plotpt(0,xc+j,yc+i,val);
	}
	set_color(MaxHues,Dir);
	WritePalette(lutc);
	do
	{
		num=do_menu_buff(menu_c,MENU_C,MENUXC,25,num,D_Grey,L_Grey,White,Font);
		if(num==4)		/* reverse */
		{
			for(k=0;k<3;k++)
			{
				lval=Dir[k][0];
				Dir[k][0]=Dir[k][1];
				Dir[k][1]=lval;
			}
			set_color(MaxHues,Dir);
			WritePalette(lutc);
		}
		if(num>=0&&num<=2)
		{
			do
			{
				ans=get_pad_color(Dir[num],&speed);
				set_color(MaxHues,Dir);
				WritePalette(lutc);
			}while(ans!=83&&ans!=13);
		}
		if(num==3)	/* Bands */
		{
			do
			{
				ans=getch();
				if(ans=='-'&&Bands>1)Bands/=2;
				if(ans=='+'&&Bands<128)Bands*=2;
				set_color(MaxHues,Dir);
				WritePalette(lutc);
			}while(ans!=83&&ans!=13);
		}
		if(num==5)	/* initialize */
		{
			Bands=1;
			Dir[0][0]=INT1;
			Dir[0][1]=INT2;
			Dir[1][0]=HUE1;
			Dir[1][1]=HUE2;
			Dir[2][0]=SAT1;
			Dir[2][1]=SAT2;
			set_color(MaxHues,Dir);
			WritePalette(lutc);
		}
	}while(num<MENU_C-1&&ans!=83&&ans!=13);
	box(0,xc-2,yc-2,0,xs+4,ys+4);
}

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

int set_color(maxhues,dir)

unsigned char maxhues[256][3];
long dir[3][2];

{
	int i,j,k;
	long val,val2,range;
	int ival;
	unsigned char color[256][3];
	
	/* set hue */

	range=dir[1][1]-dir[1][0];
	for(i=0;i<Num_Color;i++)
	{
		val=i*range;
		val/=Num_Color;
		val+=dir[1][0];
		while(val<0)val+=256;
		while(val>255)val-=256;
		j=val;
		for(k=0;k<3;k++)color[i][k]=maxhues[j][k];
	}

	/* set saturation */

	range=dir[2][1]-dir[2][0];
	for(i=0;i<Num_Color;i++)
	{
		val=i*range;
		val/=Num_Color;
		val+=dir[2][0];
		while(val<0)val+=256;
		while(val>255)val-=256;
		for(k=0;k<3;k++)
		{
			val2=color[i][k];
			val2=(255-val2)*(255-val);
			val2/=255;
			val2+=color[i][k];
			color[i][k]=val2;
		}
	}

	/* set intensity */

	range=dir[0][1]-dir[0][0];
	for(i=0;i<Num_Color;i++)
	{
		val=i*range;
		val/=Num_Color;
		val+=dir[0][0];
		while(val<0)val+=256;
		while(val>255)val-=256;
		for(k=0;k<3;k++)
		{
			val2=color[i][k];
			val2*=val;
			val2/=255;
			color[i][k]=val2;
		}
		lutc[i].r=color[i][0];
		lutc[i].g=color[i][1];
		lutc[i].b=color[i][2];
	}

	/* set Bands */
	if(Bands>1)
	{
		for(i=1;i<Num_Color;i+=Bands)
			for(j=1;j<Bands;j++)
				if((i+j)<Num_Color)
				{
					lutc[i+j].r=lutc[i].r;
					lutc[i+j].g=lutc[i].g;
					lutc[i+j].b=lutc[i].b;
				}
	}
}


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

char get_pad_color(x,speed)

long x[2];
int *speed;

{
	char ans;

	if((ans=getch())==0)
	{
		ans=getch();
		if(ans=='O')
			x[0]-=*speed;
		if(ans=='P')
		{
			x[0]-=*speed;
			x[1]-=*speed;
		}
		if(ans=='Q')
			x[1]-=*speed;

		if(ans=='G')
			x[0]+=*speed;
		if(ans=='H')
		{
			x[0]+=*speed;
			x[1]+=*speed;
		}
		if(ans=='I')
			x[1]+=*speed;
	}
	else if(ans=='-'&&*speed>2)
		*speed/=2;
	else if(ans=='+'&&*speed<128)
		*speed*=2;
	
	return(ans);
}


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

int o_ll_xy(x,y,lat,lon)

double *x,*y,lat,lon;

{
	*y=(lat-LatB[0])/LatB[1];
	*x=(lon-LonB[0])/LonB[1];
}

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

int o_xy_ll(x,y,lat,lon)

double x,y,*lat,*lon;

{
	*lat=LatB[0]+LatB[1]*y;
	*lon=LonB[0]+LonB[1]*x;
}







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

int fix_tip(txc,tyc,txs,tys,tspeed,alpha)

int *txc,*tyc,*txs,*tys,*tspeed;
double *alpha;

{
	int i,j,k;
	double cos_a,sin_a,di,dj,dxc,dyc,dtyc,dtxc,dxs,dys,rx,ry;
	int xc,yc,xs,ys;
	int val;
	float fval1,fval2,fxs,fys,fn;

	limit_tip(txc,tyc,txs,tys,tspeed,alpha);
	cos_a=cos(*alpha*DEG_RAD);
	sin_a=sin(*alpha*DEG_RAD);

	dys=ys=*tys+1;
	dxs=xs=*txs+1;
	dxc=xc=*txc-*txs/2;
	dyc=yc=*tyc-*tys/2;
	dtxc=*txc;
	dtyc=*tyc;
	fxs=xs;
	for(di=0;di<dys;di+=0.5)
	{
		for(dj=0;dj<dxs+1.0;dj+=0.5)
		{
			rx=dtxc+x_rot((dxc-dj)-dtxc,(dyc+di)-dtyc,sin_a,cos_a);
			ry=dtyc-y_rot((dxc-dj)-dtxc,(dyc+di)-dtyc,sin_a,cos_a);
			fval1=getpt(0,(int)rx,(int)ry);
			rx=dtxc+x_rot((dxc+dxs*2.0-dj)-dtxc,(dyc+di)-dtyc,sin_a,cos_a);
			ry=dtyc-y_rot((dxc+dxs*2.0-dj)-dtxc,(dyc+di)-dtyc,sin_a,cos_a);
			fval2=getpt(0,(int)rx,(int)ry);
			val=fval2*dj/fxs+fval1*(dxs-dj)/fxs;
			rx=dtxc+x_rot((dj+dxc)-dtxc,(di+dyc)-dtyc,sin_a,cos_a);
			ry=dtyc-y_rot((dj+dxc)-dtxc,(di+dyc)-dtyc,sin_a,cos_a);
			plotpt(0,(int)rx,(int)ry,val);
		}
	}
}

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

int x_rot(x,y,sin_a,cos_a)


double x,y,sin_a,cos_a;

{
		x=x*cos_a-y*sin_a;
		return(x);
}

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

int y_rot(x,y,sin_a,cos_a)

double x,y,sin_a,cos_a;

{
		y=x*sin_a+y*cos_a;
		return(y);
}


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

int limit_tip(txc,tyc,txs,tys,tspeed,alpha)

int *txc,*tyc,*txs,*tys,*tspeed;
double *alpha;

{
	int i,j,k;
	char ans;
	double a=*alpha,aspd=11.25;
	int xc=*txc,yc=*tyc,xs=*txs/2,ys=*tys/2,speed=*tspeed;

	plot_box_tip(3,xc,yc,xs,ys,a,Mbuff);
	do
	{
		ans=getch();
		unplot_box_tip(3,xc,yc,xs,ys,a,Mbuff);
		if(ans==0)
		{
			ans=getch();
			if(ans==73)
				a-=aspd;
			if(ans==71)
				a+=aspd;
			if(a>360.0)
				a-=360.0;
			if(a<0.0)a+=360.0;
			if(ans==72)
				yc-=speed;
			if(ans==75)
				xc-=speed;
			if(ans==77)
				xc+=speed;
			if(ans==80)
				yc+=speed;
		}
		else if(ans=='+')
		{
			if(speed<512)
				speed*=2;
			aspd*=2.0;
		}
		else if(ans=='-')
		{
			if(speed>1)
				speed/=2;
			aspd/=2.0;
		}
		else if(ans=='h')
			ys+=speed;
		else if(ans=='s')
			ys-=speed;
		else if(ans=='n')
			xs-=speed;
		else if(ans=='w')
			xs+=speed;
		if(ys<2)
			ys=2;
		if(xs<2)
			xs=2;
		plot_box_tip(3,xc,yc,xs,ys,a,Mbuff);
	}while(ans!=27&&ans!=83&&ans!=82&&ans!='x'&&ans!=13);
	*alpha=a;
	*txc=xc;
	*tyc=yc;
	*txs=xs*2;
	*tys=ys*2;
	*tspeed=speed;
	unplot_box_tip(3,xc,yc,xs,ys,a,Mbuff);
	return(ans);
}

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

int plot_box_tip(hue,xc,yc,xs,ys,alpha,buffer)

int hue,xc,yc,xs,ys,buffer;
double alpha;

{
	int i,j,k;
	double x[4],y[4];
	int xp[4],yp[4],num;
	double cos_a=cos(alpha*DEG_RAD),sin_a=sin(alpha*DEG_RAD);

	x[0]=x[1]=xs;
	x[2]=x[3]=-xs;
	y[0]=y[3]=ys;
	y[1]=y[2]=-ys;

	for(k=0;k<4;k++)
	{
		xp[k]=x[k]*cos_a-y[k]*sin_a;
		yp[k]=x[k]*sin_a+y[k]*cos_a;
	}
	for(k=0;k<4;k++)
	{
		if(k<3)
			i=k+1;
		else
			i=0;
		if(Reverse==0)
			num=tplot_ln(hue,xc+xp[k],yc-yp[k],xc+xp[i],yc-yp[i],
				buffer,ScreenXs,Black,White,Center);
		else
			num=tplot_ln(hue,xc+xp[k],yc-yp[k],xc+xp[i],yc-yp[i],
				buffer,ScreenXs,White,Black,Center);
		buffer+=num;
	}
}

/* ******************************************************************
**
**	draw a line on the image and save data destroyed in buffer
**
**	returns the number of points ploted
**
********************************************************************* */

int tplot_ln(hue,x1,y1,x2,y2,buffer,low_color,high_color,center)

int hue;	/* image plane */
int x1,y1;	/* coordinates of 1st point */
int x2,y2;	/* coordinates of 2nd point */
int low_color,high_color,center;
unsigned char *buffer;

{
	int numpts=0,val;
	int   i, j, k, numx, numy;
	float x, y, dy, dx;

	if(hue<0 || hue>3) return;

	numx = ( x2 > x1 ) ? x2-x1 : x1-x2;
	numy = ( y2 > y1 ) ? y2-y1 : y1-y2;

	if(numx==0 && numy==0) return;

	if( numx>numy ) 
	{
		dy = (float)(y2-y1)/(float)(x2-x1);
		dx = (x2>x1) ? 1.0 : -1.0;
		i = x = x1;
		j = y = y1;
		for(k=2;k<=(numx);k++)
		{
			if(i>=0&&i<ScreenXs&&j>=0&&j<ScreenYs)
			{
				val=buffer[numpts]=getpt(hue,i,j);
				numpts+=1;
				val=(val<center)?high_color:low_color;
				plotpt(hue,i,j,val);
			}
			x += dx;
			y += dy*dx;
			i = x+0.5;
			j = y+0.5;
		}
	}
	else
	{
		dx = (float)(x2-x1)/(float)(y2-y1);
		dy = (y2>y1) ? 1.0 : -1.0;
		i = x = x1;
		j = y = y1;
		for(k=2;k<=(numy);k++)
		{
			if(i>=0&&i<ScreenXs&&j>=0&&j<ScreenYs)
			{
				val=buffer[numpts]=getpt(hue,i,j);
				numpts+=1;
				val=(val<center)?high_color:low_color;
				plotpt(hue,i,j,val);
			}
			x += dx*dy;
			y += dy;
			i = x+0.5;
			j = y+0.5;
		}
	}
	return(numpts);
}

/* ******************************************************************
**
**	undraw a line on the image using data in buffer
**
**	returns the number of points unploted
**
********************************************************************* */

int unplot_ln(hue,x1,y1,x2,y2,buffer)

int hue;	/* image plane */
int x1,y1;	/* coordinates of 1st point */
int x2,y2;	/* coordinates of 2nd point */
unsigned char *buffer;

{
	int numpts=0,val;
	int   i, j, k, numx, numy;
	float x, y, dy, dx;

	if(hue<0 || hue>3) return;

	numx = ( x2 > x1 ) ? x2-x1 : x1-x2;
	numy = ( y2 > y1 ) ? y2-y1 : y1-y2;

	if(numx==0 && numy==0) return;

	if( numx>numy ) 
	{
		dy = (float)(y2-y1)/(float)(x2-x1);
		dx = (x2>x1) ? 1.0 : -1.0;
		i = x = x1;
		j = y = y1;
		for(k=2;k<=(numx);k++)
		{
			if(i>=0&&i<ScreenXs&&j>=0&&j<ScreenYs)
			{
				plotpt(hue,i,j,buffer[numpts]);
				numpts+=1;
			}
			x += dx;
			y += dy*dx;
			i = x+0.5;
			j = y+0.5;
		}
	}
	else
	{
		dx = (float)(x2-x1)/(float)(y2-y1);
		dy = (y2>y1) ? 1.0 : -1.0;
		i = x = x1;
		j = y = y1;
		for(k=2;k<=(numy);k++)
		{
			if(i>=0&&i<ScreenXs&&j>=0&&j<ScreenYs)
			{
				plotpt(hue,i,j,buffer[numpts]);
				numpts+=1;
			}
			x += dx*dy;
			y += dy;
			i = x+0.5;
			j = y+0.5;
		}
	}
	return(numpts);
}


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

int unplot_box_tip(hue,xc,yc,xs,ys,alpha,buffer)

int hue,xc,yc,xs,ys,buffer;
double alpha;

{
	int i,j,k;
	double x[4],y[4];
	int xp[4],yp[4],num;
	double cos_a=cos(alpha*DEG_RAD),sin_a=sin(alpha*DEG_RAD);

	x[0]=x[1]=xs;
	x[2]=x[3]=-xs;
	y[0]=y[3]=ys;
	y[1]=y[2]=-ys;

	for(k=0;k<4;k++)
	{
		xp[k]=x[k]*cos_a-y[k]*sin_a;
		yp[k]=x[k]*sin_a+y[k]*cos_a;
	}
	for(k=0;k<4;k++)
	{
		if(k<3)
			i=k+1;
		else
			i=0;
		num=unplot_ln(hue,xc+xp[k],yc-yp[k],xc+xp[i],yc-yp[i],
			buffer,ScreenXs);
		buffer+=num;
	}
}



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

int limit_area_fixed(xc,yc,xs,ys,speed,sample,x_zero,l_sample,screen)

int *xc,*yc,*xs,*ys,*speed,*sample,x_zero,l_sample,screen;

{
	int i,j,k;
	int xco=*xc,yco=*yc,xso=*xs,yso=*ys;
	char ans;

	if(screen!=2)
		screen=1;
	xso=*xs=ScreenXs/l_sample*(*sample)/screen;
	yso=*ys=ScreenYs/l_sample*(*sample);

	if(Reverse==0)
		tbox_val(3,*xc+x_zero,*yc,*xs,*ys,Mbuff,Black,White,Center);
	else
		tbox_val(3,*xc+x_zero,*yc,*xs,*ys,Mbuff,White,Black,Center);
	do
	{
		ans=getch();
		unbox(3,*xc+x_zero,*yc,*xs,*ys,Mbuff);
		if(ans==27)
		{
			return(27);
		}
		else if(ans=='-'&&*speed>1)*speed/=2;
		else if(ans=='+'&&*speed<ScreenYs)*speed*=2;
		else if(ans=='l'&&*sample<l_sample)
			*sample+=1;
		else if(ans=='s'&&*sample>1)
			*sample-=1;
		*xs=ScreenXs/screen/l_sample*(*sample);
		*ys=ScreenYs/l_sample*(*sample);

		if(ans==0)
		{
			ans=getch();
			if(ans==71)
			{
				*xc-=*speed;
				*yc-=*speed;
			}
			else if(ans==73)
			{
				*xc+=*speed;
				*yc-=*speed;
			}
			else if(ans==79)
			{
				*xc-=*speed;
				*yc+=*speed;
			}
			else if(ans==81)
			{
				*xc+=*speed;
				*yc+=*speed;
			}
			else if(ans==72)
				*yc-=*speed;
			else if(ans==80)
				*yc+=*speed;
			else if(ans==75)
				*xc-=*speed;
			else if(ans==77)
				*xc+=*speed;
		}
		if(*xs>ScreenXs/screen)*xs=ScreenXs/screen;
		if(*ys>ScreenYs)*ys=ScreenYs;
		if(*xs<2)*xs=2;
		if(*ys<2)*ys=2;
		if((*xc+*xs)>=ScreenXs/screen)*xc=ScreenXs/screen-*xs;
		if((*yc+*ys)>=ScreenYs)*yc=ScreenYs-*ys;
		if(*xc<0)*xc=0;
		if(*yc<0)*yc=0;
		if(Reverse==0)
			tbox_val(3,*xc+x_zero,*yc,*xs,*ys,Mbuff,Black,White,Center);
		else
			tbox_val(3,*xc+x_zero,*yc,*xs,*ys,Mbuff,White,Black,Center);
}while(ans!=82&&ans!=83&&ans!='x'&&ans!=27&&ans!=13);
	unbox(3,*xc+x_zero,*yc,*xs,*ys,Mbuff);
	return(ans);
}

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

int expand(filename,buffer,scale,xc,yc,iop)

char *filename;
unsigned char *buffer;
int xc,yc,iop;

{
	int i,j,k;
	int row=ImageRow,col=ImageCol,pcol,prow,val;
	long offset,lcol=ImageCol,lxc=xc,lyc=yc,lsample=Sample,offset0,lscale=scale;
	char label[100],string[100];
	FILE *fpin;

	offset=lcol*(lscale-1);
	offset0=lcol*lsample*lyc+lxc*lsample;
	fpin=fopen(filename,"rb");
	if(!fpin)
		return(-1);
	row=ImageRow;
	col=ImageCol;
	pcol=col/scale;
	prow=row/scale;
	if(pcol>ScreenXs)pcol=ScreenXs;
	if(prow>ScreenYs)prow=ScreenYs;
	fseek(fpin,offset0,SEEK_SET);
	for(i=0;i<prow;i++)
	{
		fread((char *)Mbuff,sizeof(char),col,fpin);
		if(kbhit()>0)
		{
			val=getch();
			if(val==27)
				return(-2);
		}
		fseek(fpin,offset,SEEK_CUR);
		if(GreyScale!=1)
		{
			for(j=0;j<pcol;j++)
				buffer[j]=Mbuff[j*scale]/GreyScale;
		}
		else
		{
			for(j=0;j<pcol;j++)
				buffer[j]=Mbuff[j*scale];
		}
		plotrow(3,0,pcol-1,i,buffer);	
	}
	fclose(fpin);
	return(1);
}


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

int plot_full_image(samp)

int samp;

{
	int i,j,k;
	FILE *fpin,*fpout;
	char string[100];
	int scale;
	long offset;

	ImageScale=(ImageCol+ScreenXs-1)/ScreenXs;
	scale=(ImageRow+ScreenYs-1)/ScreenYs;
	if(scale>ImageScale)
		ImageScale=scale;
	strcpy(string,InFile);
	strcat(string,ImageSuffix);
	fpin=fopen(string,"rb");
	if(!fpin)
	{
		strcpy(string,InFile);
		strcat(string,".kln");
		fpin=fopen(string,"rb");
		strcpy(string,InFile);
		strcat(string,ImageSuffix);
		fpout=fopen(string,"wb");
		offset=ImageCol;
		offset*=ImageScale-1;
		for(i=0;i<ImageRow/ImageScale;i++)
		{
			fread((char *)Mbuff,sizeof(char),ImageCol,fpin);
			fseek(fpin,offset,SEEK_CUR);
			for(j=0;j<ImageCol/ImageScale;j++)
				Mbuff[j]=Mbuff[j*ImageScale]/GreyScale;
			plotrow(3,0,ImageCol/ImageScale-1,i,Mbuff);
			fwrite((char *)Mbuff,sizeof(char),ImageCol/ImageScale,fpout);
		}
		fclose(fpin);
		fclose(fpout);
	}
	else
	{
		offset=ImageCol/ImageScale*samp*(samp-1);
		for(i=0;i<ImageRow/ImageScale;i++)
		{
			fread((char *)Mbuff,sizeof(char),ImageCol/ImageScale*samp,fpin);
			if(samp>1)
			{
				fseek(fpin,offset,SEEK_CUR);
				for(j=0;j<ImageCol/ImageScale;j++)
					Mbuff[j]=Mbuff[j*2];
			}
			plotrow(3,0,ImageCol/ImageScale-1,i,Mbuff);
		}
		fclose(fpin);
	}
}



/********************************************************************
**
**	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;
	FILE *fplut;

	if(type=='P')
	{
		fplut=fopen(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=0;k<256;k++) 
		{ 
			lut[k].r=lutc[k].r; 
			lut[k].g=lutc[k].g; 
			lut[k].b=lutc[k].b;
		} 
	}
	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); 
}

/********************************************************************
**
**     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;
	long lwide,lhigh;

	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;

	lwide=(len+1)*15/size+1;
	lhigh=30/size*num+1;

	if(lhigh*lwide>MAX_BUFF)
	{
		SetVideoMode(0);
		printf("Menu exceeded maximum buffer size\n");
		exit(0);
	}
	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,Mbuff,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,Mbuff,
						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);
			if(ans=='m')
			{
				recall_sub_mem(xc,yc,(len+1)*15/size+1,30/size*num+1);
				getch();
				paint_box(0,dgrey,Mbuff,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);
				box(0,xc,yc+val*(30/size),white,(len+1)*15/size,30/size);
			}
			if(ans==27)
				val=num-1;
		}while(ans!=13&&ans!=27);
	}
	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);
}