/*
	lbl2tga.c


	converts an '.lbl' file to a '.tga' file

*/
#include <stdio.h>
#include <string.h>
#include <malloc.h>

#define COLOR_MAP 1
#define TRUE_COLOR 2
#define B_W 3
#define NUM_IMAGE 2
#define NUM_TYPE 25
#define NUM_SIZE 25
#define MAX_LL 6

int Replicate=1,Top=0;
	unsigned char Buff1[16000],Buff4[16000][4],Buff3[16000][3];
	int Scale[NUM_IMAGE][256];
	int Range[NUM_IMAGE][3],Reverse[NUM_IMAGE];
	char Channel[3][100],ChannelOn=0;
	long Sample_Rate=1;
	int Img=0,Sample=1,Xc=0,Yc=0,Speed=16,Row,Col,ZoomSample=1,ScreenZoom=-1;
	char ProjType;
	double X0,Y0,PixelSize;	/* Albers elip */
	int Vector=0;
	struct navigation
	{
		int numlat,numlon,numx,numy;
		double B_Lat[MAX_LL],B_Lon[MAX_LL];
		double B_Y[MAX_LL],B_X[MAX_LL];
	}Nav;
	struct line_name
	{
		char filename[54];
		float max_pix,min_pix;
		int color;
	}MapFile[NUM_TYPE][NUM_SIZE];
	int Ns[NUM_TYPE];
	int Num_Active_Image=1;
	int P;
	char Group_Name[NUM_TYPE][30];

unsigned char TgaHdr[18];
struct   Color
{
	unsigned char  r, g, b;
};
struct image_header
{
	int row,col;
	int sample;
	int record_bytes,file_records;
	int record_col_header;
	int row_col_header;
	long header_bytes;
	int imbedded_header;
	int sample_bits;
	int data_max,data_min;
	char infile[100],image[100],Lut[100],pal_type,label[100];
	int vga_color[256];
	struct Color lut[256],lutm[256],lutc[256];
}Hdr[2];

int set_header(int ID_length,int color_map,int compressed,int type,
					 int cmap_start,int cmap_length,int cmap_bits,
					 int x_orig,int y_orig,int col,int row,
					 int pixel_depth,int start_top,int start_right);
unsigned char Pal[256][3];
int Packed;

main(argc,argv)

int argc;
char *argv[];

{
	int i,j,k,m;
	char string[100],name[50],cr=0xd;
	int color=0,type=3,cmap_length=0,r,g,b,colortype=0;
	FILE *fplut,*fpdat,*fptga;
	unsigned char val;
	int bits=32;
	long offset,limage,lrow,lcol,lhdr;

	if(argc<2)
	{
		printf("\n\nlbl2tga filename <options>\n");
		printf("\n");
		printf("   options:\n");
		printf("            /n -- where n = pixel bits -> 8, 24 or 32\n");
		printf(
		"          /r m -- where m = number of pixel replications (m x m)\n");
		printf("          /top -- starts image at top\n");
		printf("       /bottom -- starts image at bottom\n\n\n\n");
		exit(0);
	}
	for(k=2;k<argc;k++)
	{
		if(argv[k][0]=='/'&&argv[k][1]!='r')
			sscanf(argv[k]+1,"%d",&bits);	
		if(strcmpi(argv[k],"/r")==0&&k<argc-1)
		{
			sscanf(argv[k+1],"%d",&Replicate);
			if(Replicate<1||Replicate>10)
			{
				printf("Bad value for Replication (%d)\n",Replicate);
				exit(0);
			}
			printf("Replicating each pixel %d x %d times.\n",
						Replicate,Replicate);
		}
		if(strcmpi(argv[k],"/bottom")==0)
			Top=0;
		if(strcmpi(argv[k],"/top")==0)
			Top=1;
	}
	if(Top==0)
		printf("Image will start at bottom (use /top to reverse image)\n");
	else
		printf("Image will start at top (use /bottom to reverse image)\n");
	strcpy(name,argv[1]);
	sprintf(string,"%s.lbl",name);
	if(read_lbl(string,0)<1)
	{
		printf("Could not process '%s'\n\n",string);
		exit(0);
	}
	fplut=fopen(Hdr[0].Lut,"rt");
	if(!fplut)
	{
		printf("Could not open Color Table File -- '%s'\n\n",Hdr[0].Lut);
		exit(0);
	}
	fpdat=fopen(Hdr[0].image,"rb");
	if(!fpdat)
	{
		printf("Could not open Image -- '%s'\n\n",Hdr[0].image);
		exit(0);
	}
	if(strlen(Hdr[0].Lut)>3)
	{
		printf("Color Image -- Lut File = '%s'\n",Hdr[0].Lut);
		color=1;
		type=1;
		cmap_length=256;
	}
	printf("Image File = '%s'\n",Hdr[0].image);
	sprintf(string,"%s.tga",name);
	fptga=fopen(string,"wb");
	if(!fptga)
	{
		printf("Could not open Targa output file -- '%s'\n\n",string);
		exit(0);
	}
	printf("Image Size = %d rows x %d columns\n",Hdr[0].row,Hdr[0].col);
	if(Hdr[0].header_bytes>0)
		printf("Image Header Bytes = %d\n\n",Hdr[0].header_bytes);
	lhdr=Hdr[0].header_bytes;
	lrow=Hdr[0].row;
	lcol=Hdr[0].col;
	limage=lrow*lcol;
	if(bits==8)
	{
		set_header(0,color,0,type,0,cmap_length,24,0,0,
						Hdr[0].col*Replicate,Hdr[0].row*Replicate,
						8,Top,0);
		fwrite((char *)TgaHdr,sizeof(char),18,fptga);
		if(color==1)
		{
			for(i=0;i<256;i++)
			{
				fscanf(fplut,"%d%d%d%d",&j,&r,&g,&b);
				Pal[i][0]=b;
				Pal[i][1]=g;
				Pal[i][2]=r;
			}
			fwrite((char *)Pal,sizeof(char),256*3,fptga);
			fclose(fplut);
		}
		if(Top==0)
			fseek(fpdat,limage+lhdr-lcol,SEEK_SET);
		else
			fseek(fpdat,Hdr[0].header_bytes,SEEK_SET);
		for(i=0;i<Hdr[0].row;i++)
		{
			printf("%c%5d of %d",cr,i+1,Hdr[0].row);
			fread((char *)Buff1,sizeof(char),Hdr[0].col,fpdat);
			if(Top==0&&i<Hdr[0].row-1)
				fseek(fpdat,-lcol*(long)2,SEEK_CUR);
			if(Replicate>1)
			{
				for(j=Hdr[0].col-1;j>=0;j--)
					for(k=0;k<Replicate;k++)
						Buff1[j*Replicate+k]=Buff1[j];
				for(k=0;k<Replicate;k++)
					fwrite((char *)Buff1,sizeof(char),Hdr[0].col*Replicate,fptga);
			}
			else
				fwrite((char *)Buff1,sizeof(char),Hdr[0].col,fptga);
		}
	}
	if(bits==32)
	{
		type=2;
		colortype=cmap_length=0;
		set_header(0,colortype,0,type,0,cmap_length,0,0,0,
						Hdr[0].col*Replicate,Hdr[0].row*Replicate,
						bits,Top,0);
		fwrite((char *)TgaHdr,sizeof(char),18,fptga);
		if(color==1)
		{
			for(i=0;i<256;i++)
			{
				fscanf(fplut,"%d%d%d%d",&j,&r,&g,&b);
				Pal[i][0]=b;
				Pal[i][1]=g;
				Pal[i][2]=r;
			}
			fclose(fplut);
		}
		else
		{
			for(i=0;i<256;i++)
			{
				Pal[i][0]=i;
				Pal[i][1]=i;
				Pal[i][2]=i;
			}
		}
		if(Top==0)
			fseek(fpdat,limage+lhdr-lcol,SEEK_SET);
		else
			fseek(fpdat,Hdr[0].header_bytes,SEEK_SET);
		for(i=0;i<Hdr[0].row;i++)
		{
			printf("%c%5d of %d",cr,i+1,Hdr[0].row);
			fread((char *)Buff1,sizeof(char),Hdr[0].col,fpdat);
			if(Top==0&&i<Hdr[0].row-1)
				fseek(fpdat,-lcol*(long)2,SEEK_CUR);
			if(Replicate==1)
			{
				for(j=0;j<Hdr[0].col;j++)
				{
					k=Buff1[j];
					Buff4[j][0]=Pal[k][0];
					Buff4[j][1]=Pal[k][1];
					Buff4[j][2]=Pal[k][2];
					Buff4[j][3]=0;
				}
				fwrite((char *)Buff4,sizeof(char),Hdr[0].col*4,fptga);
			}
			else
			{
				for(j=0;j<Hdr[0].col;j++)
				{
					k=Buff1[j];
					for(m=0;m<Replicate;m++)
					{
						Buff4[j*Replicate+m][0]=Pal[k][0];
						Buff4[j*Replicate+m][1]=Pal[k][1];
						Buff4[j*Replicate+m][2]=Pal[k][2];
						Buff4[j*Replicate+m][3]=0;
					}
				}
				for(m=0;m<Replicate;m++)
					fwrite((char *)Buff4,sizeof(char),
									Hdr[0].col*4*Replicate,fptga);
			}
		}
	}
	if(bits==24)
	{
		type=2;
		colortype=cmap_length=0;
		set_header(0,colortype,0,type,0,cmap_length,0,0,0,
						Hdr[0].col*Replicate,Hdr[0].row*Replicate,
						bits,Top,0);
		fwrite((char *)TgaHdr,sizeof(char),18,fptga);
		if(color==1)
		{
			for(i=0;i<256;i++)
			{
				fscanf(fplut,"%d%d%d%d",&j,&r,&g,&b);
				Pal[i][0]=b;
				Pal[i][1]=g;
				Pal[i][2]=r;
			}
			fclose(fplut);
		}
		else
		{
			for(i=0;i<256;i++)
			{
				Pal[i][0]=i;
				Pal[i][1]=i;
				Pal[i][2]=i;
			}
		}
		if(Top==0)
			fseek(fpdat,limage+lhdr-lcol,SEEK_SET);
		else
			fseek(fpdat,Hdr[0].header_bytes,SEEK_SET);
		for(i=0;i<Hdr[0].row;i++)
		{
			printf("%c%5d of %d",cr,i+1,Hdr[0].row);
			fread((char *)Buff1,sizeof(char),Hdr[0].col,fpdat);
			if(Top==0&&i<Hdr[0].row-1)
				fseek(fpdat,-lcol*(long)2,SEEK_CUR);
			if(Replicate==1)
			{
				for(j=0;j<Hdr[0].col;j++)
				{
					k=Buff1[j];
					Buff3[j][0]=Pal[k][0];
					Buff3[j][1]=Pal[k][1];
					Buff3[j][2]=Pal[k][2];
					Buff3[j][3]=0;
				}
				fwrite((char *)Buff3,sizeof(char),Hdr[0].col*3,fptga);
			}
			else
			{
				for(j=0;j<Hdr[0].col;j++)
				{
					k=Buff1[j];
					for(m=0;m<Replicate;m++)
					{
						Buff3[j*Replicate+m][0]=Pal[k][0];
						Buff3[j*Replicate+m][1]=Pal[k][1];
						Buff3[j*Replicate+m][2]=Pal[k][2];
					}
				}
				for(m=0;m<Replicate;m++)
					fwrite((char *)Buff3,sizeof(char),
									Hdr[0].col*3*Replicate,fptga);
			}
		}
	}
	fclose(fpdat);
	fclose(fptga);
}

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

int write_image(FILE *fpdat,FILE *fptga)

{
	int i,j,k;
	long offset;
	unsigned char *buffer;
	int val;


	offset=Hdr[0].header_bytes	;
	if(offset>0)
		fseek(fpdat,offset,SEEK_SET);


	if(Packed==0)
	{
		for(i=0;i<Hdr[0].row;i++)
			for(j=0;j<Hdr[0].col;j++)
			{
				val=fgetc(fpdat);
				fwrite((char *)&val,sizeof(char),1,fptga);
			}
	}
	else
	{
		
		for(i=0;i<Hdr[0].row;i++)
			for(j=0;j<Hdr[0].col;j++)
				val=fgetc(fpdat);
			fwrite((char *)&val,sizeof(char),1,fptga);
	}
}




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

int set_header(int ID_length,int color_map,int compressed,int type,
					 int cmap_start,int cmap_length,int cmap_bits,
					 int x_orig,int y_orig,int col,int row,
					 int pixel_depth,int start_top,int start_right)

{
	TgaHdr[ 0]=ID_length;
	TgaHdr[ 1]=color_map;
	TgaHdr[ 2]=compressed*8+type;
	TgaHdr[ 3]=cmap_start%256;
	TgaHdr[ 4]=cmap_start/256;
	TgaHdr[ 5]=cmap_length%256;
	TgaHdr[ 6]=cmap_length/256;
	TgaHdr[ 7]=cmap_bits;
	TgaHdr[ 8]=x_orig%256;
	TgaHdr[ 9]=x_orig/256;
	TgaHdr[10]=y_orig%256;
	TgaHdr[11]=y_orig/256;
	TgaHdr[12]=col%256;
	TgaHdr[13]=col/256;
	TgaHdr[14]=row%256;
	TgaHdr[15]=row/256;
	TgaHdr[16]=pixel_depth;
	TgaHdr[17]=start_top*32+start_right*16;
}


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

int read_lbl(label,filenum)

char *label;
int filenum;

{
	int i,j,k;
	char string1[100],string2[100],string3[100],string[100];
	FILE *fp;
	int status=1,numread,n1,n2,n3,num;
	double lat0,lat1,lat2,lon0;

	fp=fopen(label,"rt");	
	if(!fp)
		return(-1);
	Hdr[filenum].header_bytes=0;
	Hdr[filenum].sample_bits=8;
	Hdr[filenum].record_bytes=0;
	Hdr[filenum].file_records=0;
	Hdr[filenum].pal_type=0;
	Hdr[filenum].row_col_header=0;
	ProjType=0;

	Hdr[filenum].infile[0]='\0';
	Hdr[filenum].image[0]='\0';
	Hdr[filenum].Lut[0]='\0';
	Hdr[filenum].label[0]='\0';

	for(i=0;i<NUM_IMAGE;i++)
		Reverse[i]=0;
	Nav.numlat=Nav.numlon=0;
	Nav.numy  =Nav.numy  =0;
	Hdr[filenum].data_min=0;
	Hdr[filenum].data_max=255;
	Sample_Rate=1;
	ChannelOn=Vector=0;
	while(fscanf(fp,"%s",string1)==1)
	{
		if(strcmpi(string1,"end")==0)
		{
			fclose(fp);
			return(status);
		}
		if(strcmpi(string1,"image_lines")==0&&Hdr[filenum].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",&Hdr[filenum].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",&Hdr[filenum].sample_bits);
		}
		if(strcmpi(string1,"CHANNEL_INPUT:")==0)
		{
			ChannelOn=1;
			while(fgetc(fp)!=0xa);	/* skip to end of line */
			for(k=0;k<3;k++)
			{
				if(!fgets(string1,99,fp))
				{
					printf("Invalid CHANNEL_INPUT:\n");
					exit(0);
				}
				sscanf(string1+13,"%s",Channel[k]);
			}
		}
		if(strcmpi(string1,"SAMPLE_RATE")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			sscanf(string3,"%ld",&Sample_Rate);
			if(Sample_Rate<1||Sample_Rate>30)
			{
				printf("Invalid SAMPLE_RATE = %ld\n",Sample_Rate);
				exit(0);
			}
		}
		if(strcmpi(string1,"Projection")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				fclose(fp);
				return(status);
			}
			ProjType=string3[0];
			if(ProjType=='A')
			{
				while(fgetc(fp)!=0xa);	/* skip to end of line */
				fgets(string1,100,fp);
				sscanf(string1,"%lf",&lat0);
				fgets(string1,100,fp);
				sscanf(string1,"%lf",&lat1);
				fgets(string1,100,fp);
				sscanf(string1,"%lf",&lat2);
				fgets(string1,100,fp);
				sscanf(string1,"%lf",&lon0);
				fgets(string1,100,fp);
				sscanf(string1,"%lf",&X0);
				fgets(string1,100,fp);
				sscanf(string1,"%lf",&Y0);
				fgets(string1,100,fp);
				sscanf(string1,"%lf",&PixelSize);
				fgets(string1,100,fp);
				sscanf(string1,"%d",&P);
/*				set_const(P,lat0,lat1,lat2,lon0);*/
			}
		}
		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",&Hdr[filenum].row);
			Hdr[filenum].file_records=Hdr[filenum].row;
		}
		if(strcmpi(string1,"line_samples")==0&&Hdr[filenum].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",&Hdr[filenum].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",&Hdr[filenum].col);
			Hdr[filenum].record_bytes=Hdr[filenum].col;
		}
		if(strcmpi(string1,"header_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,"%ld",&Hdr[filenum].header_bytes);
		}
		if(strcmpi(string1,"data_max")==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",&Hdr[filenum].data_max);
		}
		if(strcmpi(string1,"data_min")==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",&Hdr[filenum].data_min);
		}
		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 */
					Hdr[filenum].image[k++]=string3[i];
			Hdr[filenum].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';
			Hdr[filenum].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 */
					Hdr[filenum].Lut[k++]=string3[i];
			Hdr[filenum].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);
			}			
			Hdr[filenum].row_col_header=1;
			Hdr[filenum].header_bytes=4;
		}
		if(strcmpi(string1,"latitude_coef")==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",&Nav.numlat);
			if(Nav.numlat>MAX_LL||Nav.numlat<2)
			{
				printf("Invalid number of Latitude coefficients '%s'\n\n",string3);
				exit(0);
			}
			for(i=0;i<Nav.numlat;i++)
			{
				fscanf(fp,"%s",string3);
				if(sscanf(string3,"%lf",Nav.B_Lat+i)<1)
				{
					printf("Invalid latitude '%s'\n\n",string3);
					exit(0);
				}
			}
		}
		if(strcmpi(string1,"y_coef")==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",&Nav.numy);
			if(Nav.numy>MAX_LL||Nav.numy<2)
			{
				printf("Invalid number of Y coefficients '%s'\n\n",string3);
				exit(0);
			}
			for(i=0;i<Nav.numy;i++)
			{
				fscanf(fp,"%s",string3);
				if(sscanf(string3,"%lf",Nav.B_Y+i)<1)
				{
					printf("Invalid Y coef. '%s'\n\n",string3);
					exit(0);
				}
			}
		}
		if(strcmpi(string1,"longitude_coef")==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",&Nav.numlon);
			if(Nav.numlon>MAX_LL||Nav.numlon<2)
			{
				printf("Invalid number of longitude coefficients '%s'\n\n",string3);
				exit(0);
			}
			for(i=0;i<Nav.numlon;i++)
			{
				fscanf(fp,"%s",string3);
				if(sscanf(string3,"%lf",Nav.B_Lon+i)<1)
				{
					printf("Invalid longitude '%s'\n\n",string3);
					exit(0);
				}
			}
		}
		if(strcmpi(string1,"x_coef")==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",&Nav.numx);
			if(Nav.numx>MAX_LL||Nav.numx<2)
			{
				printf("Invalid number of X coefficients '%s'\n\n",string3);
				exit(0);
			}
			for(i=0;i<Nav.numx;i++)
			{
				fscanf(fp,"%s",string3);
				if(sscanf(string3,"%lf",Nav.B_X+i)<1)
				{
					printf("Invalid X coef. '%s'\n\n",string3);
					exit(0);
				}
			}
		}
		if(strcmpi(string1,"set_pointer")==0||strcmpi(string1,"set_pointers")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				printf("invalid 'set_pointer' format\n\n");
				exit(0);
			}
			sscanf(string3,"%d",&Num_Active_Image);
			if(Num_Active_Image>=NUM_IMAGE)
			{
				printf("Invalid number of images in set.\n\n");
				exit(0);
			}
			for(i=0;i<Num_Active_Image;i++)
			{
				Range[i][0]=0;
				Range[i][1]=127;
				Range[i][2]=255;
			}
			for(i=0;i<Num_Active_Image;i++)
			{
				if(!fgets(string,99,fp))
				{
					printf("Error reading 'set_pointer'\n");
					exit(0);
				}
				num=sscanf(string,"%s%d%d%d",string1,&n1,&n2,&n3);
				if(num<1||strlen(string)==0)
				{
					fgets(string,99,fp);
					num=sscanf(string,"%s%d%d%d",string1,&n1,&n2,&n3);
				}
				if(num==4)
				{
					Range[i][0]=n1;
					Range[i][1]=n2;
					Range[i][2]=n3;
				}
				if(num==3)
				{
					Range[i][0]=n1;
					Range[i][2]=n2;
					Range[i][1]=(Range[i][0]+Range[i][1])/2;
				}
				copy_hdr(i,0);
				strcpy(Hdr[i].image,string1);
			}
			return(Num_Active_Image);
		}
		if(strcmpi(string1,"vector_sets")==0)
		{
			numread=fscanf(fp,"%s%s",string2,string3);
			if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
				numread<2)
			{
				printf("invalid 'vector_sets' format\n\n");
				exit(0);
			}
			sscanf(string3,"%d",&Vector);
			if(Vector<1||Vector>=NUM_TYPE)
			{
				printf("Invalid number of vector sets.\n");
				exit(0);
			}
			for(i=0;i<Vector;i++)
			{
				numread=fscanf(fp,"%s%s%s",Group_Name[i],string2,string3);
				if(strcmpi(string2,"end")==0||strcmpi(string3,"end")==0||
					numread<2)
				{
					printf("invalid 'vector_set' format at set %d\n\n",i+1);
					exit(0);
				}
				sscanf(string3,"%d",Ns+i);
				if(Ns[i]<1||Ns[i]>=NUM_SIZE)
				{
					printf("Invalid number of vectors.\n");
					exit(0);
				}
				for(j=0;j<Ns[i];j++)
				{
					numread=fscanf(fp,"%s%f%f%d",
						MapFile[i][j].filename,&MapFile[i][j].max_pix,
						&MapFile[i][j].min_pix,&MapFile[i][j].color);
					if(numread<4)
					{
						printf("invalid 'vector' format at set i=%d j=%d\n\n",
							i+1,j+1);
						exit(0);
					}
				}
			}
		}
	}
	fclose(fp);
	return(status);
}

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

int copy_hdr(d,s)

int d,s;  /* (d)estination and (s)ource */

{
	int i,j,k;

	Hdr[d].row=Hdr[s].row;
	Hdr[d].col=Hdr[s].col;
	Hdr[d].sample=Hdr[s].sample;
	Hdr[d].record_bytes=Hdr[s].record_bytes;
	Hdr[d].file_records=Hdr[s].file_records;
	Hdr[d].record_col_header=Hdr[s].record_col_header;
	Hdr[d].row_col_header=Hdr[s].row_col_header;
	Hdr[d].header_bytes=Hdr[s].header_bytes;
	Hdr[d].imbedded_header=Hdr[s].imbedded_header;
	Hdr[d].sample_bits=Hdr[s].sample_bits;
	Hdr[d].pal_type=Hdr[s].pal_type;

	strcpy(Hdr[d].infile,Hdr[s].infile);
	strcpy(Hdr[d].image,Hdr[s].image);
	strcpy(Hdr[d].Lut,Hdr[s].Lut);
	strcpy(Hdr[d].label,Hdr[s].label);

	for(i=0;i<256;i++)
	{
		Hdr[d].vga_color[i]=Hdr[s].vga_color[i];

		Hdr[d].lut[i].r=Hdr[s].lut[i].r;
		Hdr[d].lut[i].g=Hdr[s].lut[i].g;
		Hdr[d].lut[i].b=Hdr[s].lut[i].b;
		Hdr[d].lutm[i].r=Hdr[s].lutm[i].r;
		Hdr[d].lutm[i].g=Hdr[s].lutm[i].g;
		Hdr[d].lutm[i].b=Hdr[s].lutm[i].b;
		Hdr[d].lutc[i].r=Hdr[s].lutc[i].r;
		Hdr[d].lutc[i].g=Hdr[s].lutc[i].g;
		Hdr[d].lutc[i].b=Hdr[s].lutc[i].b;
	}
}