/*
 *	Name	t.c -- Interactive test program for ITEX100
 *	Author E. Poullain - August 1985
 *	Revision History
 *	26 june 86	E. Poullain
 *			added version number and corrected a few bugs
 *	4 Mar 86	P. Mack
 *			Changed UNSIGNED type casting to UWORD.
 *
 *	February 1991 - Dr. Roger W. Webster made some minor changes
 *	                    for SUN330 Sparc Station platform
 */
#define SUN YES
#include <stdio.h>
#include <stdtyp.h>
#include <itex100.h>
#include <boards.h>

static int	option;
static int	x, y, z, dx, dy;

geti(name, iptr) 
char *name;
int *iptr;
{

	printf("%s: ", name);
	scanf("%d", iptr);
}

getu(name, uptr)
char *name;
unsigned int *uptr;
{

	printf("%s (hex): ", name);
	scanf("%x", uptr);
}

getl(name, lptr)
char *name;
long *lptr;
{

	printf("%s (hex): ", name);
	scanf("%lx", lptr);
}

getarea()
{

	geti("\nX start", &x);
	geti("Y start", &y);
	geti("X size", &dx);
	geti("Y size", &dy);
}

wwait()
{

	printf("\nPress return to continue ");     
	while (getchar() != '\n')		/* Skip pending CR */
		;
	while (getchar() != '\n')        /*	wwait for an explicit one */
		;
}

main()
{
       unsigned         base = 0x1000;
       long             mem  = 0xa00000L;
       int             flag = 1, block = 1;

	printf("Hardware initialization\n");
	sethdw(base, mem, flag, block);
	initialize();
	initregs();
	initluts();
        grab(0);
	while (1) {
		printf("\n ***** ITEX/100 TEST PROGRAM *****\n");
		printf("\n 0:QUIT");
		printf("\n 2:Hardware definition and initialization");
		printf("\n 3:Register operations");
		printf("\n 4:Acquire and clear operations");
		printf("\n 5:Pixel read and write operations");
		printf("\n 6:Image save and restore");
		printf("\n 7:Look-up table operations");
		printf("\n 8:Line and area operations");
		printf("\n 9:Image filtering and processing");
		printf("\n10:Image geometry");
		printf("\n11:Graphics");
		printf("\n12:Bit manipulations");
		printf("\n13:Movies and Real time");
		geti("\nSelect an option by its number", &option);

		switch (option) {
		case 0: 
			return;
		case 2:
			menu2();
			break;
		case 3:
			menu3();
			break;
		case 4:
			menu4();
			break;
		case 5:
			menu5();
			break;
		case 6:
			menu6();
			break;
		case 7:
			menu7();
			break;
		case 8:
			menu8();
			break;
		case 9:
			menu9();
			break;
		case 10:
			menu10();
			break;
		case 11:
			menu11();
			break;
		case 12:
			menu12();
			break;
		case 13:
			menu13();
			break;
		default:
			break;
		}
	}
}

menu2()
{
	char			c;
	unsigned int	regb, flag, block, uu;
	long			memb;

	for (;;) {
		printf("\n***** HARDWARE DEFINITION AND INITIALIZATION *****");
		printf("\n");
		printf("\n 0:Return to main menu");
		printf("\n 1:Sethdw");
		printf("\n 2:Gethdw");
		printf("\n 3:Initialize");
		printf("\n 4:Initregs");
		printf("\n 5:Initluts");
		printf("\n 6:Setdim");
		printf("\n 7:Getdim");
		geti("\nFunction", &option);
		switch (option) {
		case 0:return;
		case 1:
			getu("Register base", &regb);
			getl("Memory base", &memb);
			getu("Flag", &flag);
			getu("Block", &block);
			sethdw(regb, memb, flag, block);
			break;
		case 2:
			gethdw(&regb, &memb, &flag, &block);
			printf("\nRegister base address: %x", regb);
			printf("\nMemory base address: %lx", memb);
			printf("\nBoard type: %s",
				(flag == PSEUDO_COLOR) ? "pseudo colour" : "monochrome");
			printf("\nBlocks mapped in: %x\n", block);
			wwait();	
			break;
		case 3:	
			initialize();
			break;
		case 4:
			initregs();
			break;
		case 5: 
			initluts();
			break;
		case 6: 
			geti("X dimension", &x);
			geti("Y dimension", &y);
			geti("Depth", &z);
			setdim(x, y, z);
			break;
		case 7: 
			getdim(&x, &y, &z);
			printf("\nx = %d", x);
			printf("\ny = %d", y);
			printf("\nz = %d", z);
			wwait();
			break;
		default:
			break;
		}
	}
}

menu3()
{
	unsigned int offset, val;
	unsigned int regb,flag,block;
	long memb;

	gethdw(&regb,&memb,&flag,&block);
	for(;;) {
		printf("\n***** REGISTER OPERATIONS *****");
		printf("\n");
		printf("\n 0:Return to main menu");
		printf("\n 1:Setreg");
		printf("\n 2:Getreg");
		printf("\n 3:Andreg");
		printf("\n 4:Orreg");
		printf("\n 5:Testreg");
		printf("\n 6:Waitvb");
		printf("\n 7:Waithb");
		printf("\n 9:Zoom");
		printf("\n10:Pan");
		printf("\n11:Scroll");
		printf("\n12:Getpan");
		printf("\n13:Getscroll");
		printf("\n14:Getzoom");
		printf("\n15:panb");
		printf("\n16:scrollb");
		printf("\n17:Getbpan");
		printf("\n18:Getbscroll");
		printf("\n19:Dualscan");
		geti("\nFunction", &option);

		if(option > 14 && flag !=2){
			printf("\n available only for fg-101 type board ");
			wwait();
			continue;
		}
		switch(option){
		case 0:return;
		case 1:
			getu("\noffset", &offset);
			getu("newval", &val);
			setreg(offset, val);
			break;
		case 2:
			getu("\noffset", &offset);
			printf("value = %x", getreg(offset));
			wwait();
			break;
		case 3:
			getu("\noffset", &offset);
			getu("andval", &val);
			andreg(offset, val);
			break;
		case 4:
			getu("\noffset", &offset);
			getu("orval", &val);
			orreg(offset, val);
			break;
		case 5:
			getu("\noffset", &offset);
			getu("maskval", &val);
			printf("value = %x", testreg(offset, val));
			wwait();
			break;
		case 6:
			waitvb();
			break;
		case 7: 
			waithb();
			break;
		case 9:
			getu("\nzoomval\n", &val);
			zoom(val);
			break;
		case 10:
			getu("\ncolumns", &val);
			pan(val);
			break;
		case 11:
			getu("\nrows", &val);
			scroll(val);
			break;
		case 12: 
			printf("\nvalue = %x", getpan());
			wwait();	
			break;
		case 13: 
			printf("\nvalue = %x", getscroll());
			wwait();
			break;
		case 14:
			printf("\nvalue = %x", getzoom());
			wwait();
			break;
		case 15:
			getu("\ncolumns", &val);
			panb(val);
			break;
		case 16:
			getu("\nrows", &val);
			scrollb(val);
			break;
		case 17: 
			printf("\nvalue = %x", getbpan());
			wwait();	
			break;
		case 18: 
			printf("\nvalue = %x", getbscroll());
			wwait();
			break;
		case 19:
			getu("\nstate",&val);
			printf("\nvalue = %x", dualscan(val));
			break;
		default:
			break;
		}
	}
}

menu4()
{
	int				iarg, color;
	unsigned int	msk;

	for (;;) {
		printf("\n***** ACQUIRE AND CLEAR OPERATIONS *****\n");
		printf("\n 0:return to main menu");
		printf("\n 1:setvmask");
		printf("\n 2:snap");
		printf("\n 3:grab");
		printf("\n 4:stopgrab");
		printf("\n 5:hlclear");
		printf("\n 6:aclear");
		printf("\n 7:vlclear");
		printf("\n 8:sclear");
		printf("\n 9:setpmask");
		printf("\n10:getvmask");
		printf("\n11:getpmask");
		geti("\nFunction", &option);

		switch (option) {
		case 0:return;
		case 1:
			getu("\nmask", &msk);
			setvmask(msk);
			break;
		case 2:
			geti("\nwaitflag", &iarg);
			snap(iarg);
			break;
		case 3:
			geti("\nframes", &iarg);
			grab(iarg);
			break;
		case 4:
			geti("\nwaitflag", &iarg);
			stopgrab(iarg);
			break;
		case 5:
			geti("\nx start", &x);
			geti("y start", &y);
			geti("number of pixels", &dx);
			geti("color", &color);
			hlclear(x, y, dx, color);
			break;
		case 6:
			getarea();
			geti("color", &color);
			aclear(x, y, dx, dy, color);
			break;
		case 7:
			geti("\nx start", &x);
			geti("y start", &y);
			geti("number of pixels", &dx);
			geti("color", &color);
			vlclear(x, y, dx, color);
			break;
		case 8:
			geti("\ncolor", &color);
			sclear(color);
			break;
		case 9: 
			getu("\nmask", &msk);
			setpmask(msk);
			break;
		case 10: 
			printf("\n value = %x", getvmask());
			wwait();
			break;
		case 11: 
			printf("\n value = %x", getpmask());
			wwait();
			break;	
		default:
			break;
		}
	}
}

static unsigned  pixarray[512];
static BYTE 	 bytearray[512];
static UWORD 	 wordarray[512];

menu5()
{
	int		x, y, datum, n, i;
	UWORD 	wdatum;
	BYTE	bdatum;

	for (;;) {
		printf("\n***** PIXEL READ AND WRITE OPERATIONS *****\n");
		printf("\n 0:return to main menu");
		printf("\n 1:wpixel");
		printf("\n 2:rpixel");
		printf("\n 3:whline");
		printf("\n 4:rhline");
		printf("\n 5:bwhline");
		printf("\n 6:brhline");
		printf("\n 7:rvline");
		printf("\n 8:wvline");
		printf("\n 9:bwpixel");
		printf("\n10:brpixel");
		printf("\n11:wwpixel");
		printf("\n12:wrpixel");
		printf("\n13:bwvline");
		printf("\n14:brvline");
		printf("\n15:wwvline");
		printf("\n16:wrvline");
		printf("\n17:wwhline");
		printf("\n18:wrhline");
		geti("\nFunction", &option);

		if (!option)								/* Test for Menu Return */
			return;
		/*
		 *	Every function requires at least a starting point, so ask for it
		 * here already.
		 */
		geti("\nX", &x);
		geti("Y", &y);

		switch (option) {
		case 1:
			geti("datum", &datum);
			wpixel(x, y, datum);
			break;
		case 2:
			printf("\npixel value = %d\n", rpixel(x, y));
			wwait();
			break;
		case 9:
			geti("datum", &datum);
			wdatum = (UWORD)wdatum;
			wwpixel(x, y, wdatum);
			break;
		case 10:
			printf("\npixel value = %d\n", wrpixel(x, y));
			wwait();
			break;
		case 11:
			geti("datum", &datum);
			bdatum = (BYTE)datum;
			bwpixel(x, y, bdatum);
			break;
		case 12:
			printf("\npixel value = %d\n", brpixel(x, y));
			wwait();
			break;
		case 5:
		case 13:
			geti("number of pixels to write (1-20 here for convenience) ", &n);
			if (n > 20)
				n = 20;
			for (i = 0;  i < n;  i++) {
				printf("Value %d: ", i);
				scanf("%d", &datum);
				bytearray[i] = (BYTE)datum;
			}
			if (option == 5)
				bwhline(x, y, n, bytearray);
			else
				bwvline(x, y, n, bytearray);
			break;
		case 3:
		case 8:
			geti("Number of pixels to write (1-20 here for convenience) ", &n);
			if (n > 20)
				n = 20;
			for (i = 0;  i < n;  i++){
				printf(" value %d: ", i);
				scanf("%d", &pixarray[i]);
			}
			if(option == 3) 
				whline(x, y, n, pixarray);
			if(option == 8) 
				wvline(x, y, n, pixarray);
			break;
		case 15:
		case 17:
			geti("Number of pixels to write (1-20 here for convenience) ", &n);
			if (n > 20)
				n = 20;
			for (i = 0;  i < n;  i++) {
				printf(" value %d: ", i);
				scanf("%d", &datum);
				wordarray[i] = (UWORD)datum;
			}
			if (option == 15)
				wwvline(x, y, n, wordarray);
			else
				wwhline(x, y, n, wordarray);
			break;
		case 4:
		case 6:
		case 7:
		case 14:
		case 16:
		case 18:
			geti("number of pixels to read", &n);
			if (option == 4) 
				 rhline(x, y, n, pixarray);
			else if (option == 7) 
				 rvline(x, y, n, pixarray);
			else if (option == 6) 
				 brhline(x, y, n, bytearray);
			else if (option == 14)
				 brvline(x, y, n, bytearray);
			else if (option == 16)
				 wrvline(x, y, n, wordarray);
			else if (option == 18)
				 wrhline(x, y, n, wordarray);
			if (option == 4 || option == 7) {
				for (i = 0;  i < n;  i++)
					printf("\nentry %d: %d", i, pixarray[i]);
			}
			else
			if (option == 6  || option == 14) {
				for (i = 0;  i < n;  i++)
					printf("\nentry %d: %d", i, (int)bytearray[i]);
			}
			else {
				for (i = 0;  i < n;  i++)
					printf("\nentry %d: %d", i, (int)wordarray[i]);
			}
			wwait();
			break;
		default:
			break;
		}
	}
}

menu6(){

	int		comflag, result;
	int		type = EIGHT_BIT;
	char	comment[256], name[256]; 
	int		code, errnum;
	int		i;

	for (;;) {
		printf("\n***** IMAGE SAVE AND RESTORE *****\n");
		printf("\n 0:return to main menu");
		printf("\n 1:saveim");
		printf("\n 2:readim");
		geti("\nFunction", &option);

		switch (option) {
		case 0:
			return;
		case 1:
			getarea();
			geti("Image file type", &type);
			printf("File name = ");
			scanf("%s", name);
			printf("Image comment = ");
			scanf("%s", comment);
			errnum = saveim(x, y, dx, dy, type, name, comment);
			printf("\nError returned: %d", errnum);
			wwait();
			break;		
		case 2:
			getarea();
			printf("File name = ");
			scanf("%s", name);
			errnum = readim(x, y, dx, dy, name, comment);
			if( ! errnum) printf("\nImage comment:  %s", comment);
			printf("\nError returned: %d", errnum);
			wwait();
			break;
		default:
			break;
		}
	}
}



static BYTE	lutbarray[255];
static UWORD	lutwarray[255];
static unsigned int	lutarray[255];

menu7()
{
	unsigned int color, bank, offset, mode, cnt;
	int addr, val, range, i, errnum;
	char name[30];
	UWORD wval;

	for (;;) {
		printf("\n***** LOOK-UP TABLE OPERATIONS *****\n");
		printf("\n 0:return to main menu");
		printf("\n 1:setlut           23:wwlut");
		printf("\n 3:linlut           24:wrlut");
		printf("\n 4:invlut           25:wwalut");
		printf("\n 5:loglut           26:wralut");
		printf("\n 6:abslut");
		printf("\n 7:spectrum");
		printf("\n 8:maplut");
		printf("\n 9:wlut");
		printf("\n10:rlut");
		printf("\n11:coloredges");
		printf("\n12:bwalut");
		printf("\n13:bralut");
		printf("\n14:rollut");
		printf("\n15:contour");
		printf("\n16:threshold");
		printf("\n17:walut");
		printf("\n18:ralut");
		printf("\n19:dynamic_luts");
		printf("\n20:static_luts");
		printf("\n21:savelut");
		printf("\n22:readlut");
		geti("\nFunction", &option);

		switch (option) {
		case 0:return;
		case 1:
			getu("\nColor", &color);
			getu("Bank", &bank);
			setlut(color, bank);
			break;
		case 3:
			getu("\nColor", &color);
			getu("Bank", &bank);
			linlut(color, bank);
			break;
		case 4: 
			getu("\nColor", &color);
			getu("Bank", &bank);
			invlut(color, bank);
			break;
		case 5: 
			getu("\nColor", &color);
			getu("Bank", &bank);
			loglut(color, bank);
			break;
		case 6: 
			getu("\nColor", &color);
			getu("Bank", &bank);
			abslut(color, bank);
			break;
		case 7: 
			getu("\nBank", &bank);
			spectrum(bank);
			break;
		case 8:
			getarea();
			getu("\nColor", &color);
			getu("Bank", &bank);
			maplut(color, bank, x, y, dx, dy);
			break;
		case 23:
		case 9:
			geti("\nLut address (0-255)", &addr);
			getu("Color", &color);
			getu("Bank", &bank);
			if (option == 9) {
				geti("Lut value (0-255)", &val);
				wlut(color, bank, addr, val);
			}
			else {
				geti("Lut value (0-255)", &wval);
				wwlut(color, bank, addr, wval);
			}
			break;
		case 10:
		case 24:
			getu("\nColor", &color);
			getu("Bank", &bank);
			geti("Lut address (0-255)", &addr);
			if (option == 10)
				printf("Lut value=%d", rlut(color, bank, addr));
			else 
				printf("Lut value=%d", wrlut(color, bank, addr));
			wwait();
			break;
		case 11:
			getu("\nBank", &bank);
			coloredges(bank);
			break;	
		case 12:
		case 17:
		case 25:
			getu("\nColor", &color);
			getu("Bank", &bank);
			geti("Offset in lut table", &addr);
			printf("Entries limited to 10 here");
			geti("\nNumber of entries", &range);
			if (range > 10) 
				range = 10;
			for (i = 0; i < range;  i++) {
				printf("entry %d : ", i);
				scanf("%d", &val);
				if (option == 12)
				   lutbarray[i] = (BYTE)val;
				else if (option == 17) 
				   lutarray[i] = val;
				else 
				   lutwarray[i] = (UWORD)val;
			}
			if (option == 12)
				bwalut(color, bank, addr, range, lutbarray);
			else if (option == 17) 
				walut(color, bank, addr, range, lutarray);
			else
				wwalut(color, bank, addr, range, lutwarray);
			break;
		case 18:
		case 13:
		case 26:
			getu("\nColor", &color);
			getu("Bank", &bank);
			geti("Offset in lut table", &addr);
			geti("Number of entries to read", &range);
			if (option == 18) {
				ralut(color, bank, addr, range, lutarray);
				for (i = 0;  i < range;  i++)
					printf("\nlut entry %d : %d", i+addr, lutarray[i]);
			}
			else if (option ==13) {
				bralut(color, bank, addr, range, lutbarray);
				for (i = 0;  i < range;  i++)
					printf("\nlut entry %d : %d", i+addr, (int)lutbarray[i]);
			}
			else {
				bwalut(color, bank, addr, range, lutwarray);
			    for (i = 0;  i < range;  i++)
					printf("\nlut entry %d : %d", i+addr, (int)lutwarray[i]);
			}
			wwait();
			break;
		case 14:
			getu("\nColor", &color);
			getu("Bank", &bank);
			geti("Amount", &val);
			rollut(color, bank, val);
			break;
		case 15:
			getu("\nColor", &color);
			getu("Bank", &bank);
			geti("Lut address start", &addr);
			geti("Range", &range);
			geti("Intensity", &val);
			contour(color, bank, addr, range, val);
			break;
		case 16:
			getu("\nColor", &color);
			getu("Bank", &bank);
			geti("Lowcut", &range);
			geti("Highcut", &val);
			threshold(color, bank, val, range);
			break;
		case 19:
			dynamic_luts();
			break;
		case 20: 
			static_luts();
			break;
		case 21: 
			printf("\nFile name = ");
			scanf("%s", name);
			getu("Color", &color);
			getu("Bank", &bank);
			geti("Offset", &offset);
			geti("File open mode", &mode);
			geti("Count", &cnt);
			errnum = savelut(name, color, bank, offset, cnt, mode);
			if (errnum < 0){
			 	printf("\nError %d\n", errnum);
				wwait();
			}
			break;
		case 22: 
			printf("\nFile name = ");
			scanf("%s", name);
			errnum = readlut(name);
			printf("\nError %d\n", errnum);
			wwait();
			break;
		}
	}
}


static unsigned buffer[512];

menu8()
{
	int mode, arg, x1, x2, y1, y2, dx1, dy1, i, color;

	for (;;) {
		printf("\n***** LINE AND AREA OPERATIONS *****\n");
		printf("\n 0:return to main menu");
		printf("\n 1:cline");
		printf("\n 2:mline");
		printf("\n 3:opline");
		printf("\n 4:carea");
		printf("\n 5:marea");
		printf("\n 6:oparea");
		printf("\n 7:complement");
		printf("\n 8:negate");
		printf("\n 9:qclear");
		printf("\n10:line"); 
		geti("\nFunction", &option);

		switch (option) {
		case 0:
			return;
		case 1:
			printf("\nSource line:");
			geti("X start", &x1);
			geti("Y start", &y1);
			printf("\nDestination line:");
			geti("X start", &x);
			geti("Y start", &y);
			geti("Number of pixels to copy", &dx1);
			cline(x1, y1, dx1, x, y);
			break;
		case 2:
		case 3:
			geti("Logical mode", &mode);
			geti("\nX start", &x1);
			geti("Y start", &y1);
			geti("Number of pixels", &dx1);
			if (option == 2) {
				geti("Argument", &arg);
				mline(x1, y1, dx1, mode, arg);
			}
			else { 
				for (i = 0;  i < dx1;  i++) {
					printf("Pixel %d : ", i);
					scanf("%d", &arg);
					buffer[i] = (unsigned) arg;
				}
				geti("Output mode", &arg);
				opline(x1, y1, dx1, mode, arg, buffer);
			}
			break;
		case 4:
			printf("\nSource area:");
			getarea();
			x1 = x;  y1 = y;  dx1 = dx;  dy1 = dy;
			printf("\nDestination area:");
			getarea();
			carea(x1, y1, dx1, dy1, x, y, dx, dy);
			break;
		case 5:
			getarea();
			geti("Logical mode", &mode);
			geti("Argument", &arg);
			marea(x, y, dx, dy, mode, arg);
			break;
		case 6:
			printf("\nSource area:");
			getarea();
			x1 = x;  y1 = y;  dx1 = dx;  dy1 = dy;
			printf("\nDestination area:");
			getarea();
			geti("Logical mode", &mode);
			geti("Output mode", &arg);
			oparea(x1, y1, dx1, dy1, x, y, dx, dy, mode, arg);
			break;
		case 7:
			getarea();
			complement(x, y, dx, dy);
			break;
		case 8:
			getarea();
			negate(x, y, dx, dy);
			break;
		case 9:
			geti("Quadrant", &mode);
			geti("Color", &color);
			qclear(mode, color);
			break;
		case 10:
			geti("\nX1 ", &x);
			geti("Y1 ", &y);
			geti("X2 ", &dx);
			geti("Y2 ", &dy);
			geti("Color ", &color);
			line(x, y, dx, dy, color);
			break;
		default:
			break;
		}
	}
}


static int		ker3[9], ker5[25], ker7[49];
static long	histarray[256];

menu9()
{
	int	nf, factor, outflag, i, thresh, offset, xs, ys;
	int	bsize, color, bank, n, m;

	for (;;) {
		printf("\n***** IMAGE FILTERING AND PROCESSING *****\n");
		printf("\n 0:return to main menu");
		printf("\n 2:conv3x3");
		printf("\n 3:conv5x5");
		printf("\n 4:conv7x7");
		printf("\n 5:enhoriz");
		printf("\n 6:envert");
		printf("\n 7:laplacian");
		printf("\n 8:lopass");
		printf("\n 9:sharpen");
		printf("\n10:blur");
		printf("\n11:histeq");
		printf("\n12:roberts");
		printf("\n13:sobel");
		printf("\n14:coloredges");
		printf("\n16:dilate");
		printf("\n18:histogram");
		printf("\n19:swap6");
		printf("\n20:erode");
		geti("\nFunction", &option);

		switch (option) {
		case 0:
			return;
		case 2:
			getarea();	
			geti("scale factor (power of 2)", &factor);
			geti("offset (0-255)", &offset);
			geti("output mode", &outflag);
			printf("\nenter kernel values separated by a space\n");
			for(i=0;i<9;i +=3){
			  printf("\nline %d: ", i/3 +1);
			  scanf("%d%d%d", &ker3[i], &ker3[i+1], &ker3[i+2]);
			}
			conv3x3(x, y, dx, dy, factor, offset, outflag, ker3);
			break;
		case 3:
			getarea();	
			geti("scale factor (power of 2)", &factor);
			geti("offset (0-255)", &offset);
			geti("output mode", &outflag);
			printf("\nenter kernel values separated by a space\n");
			for(i=0;i<25;i +=5){
			   printf("\nline %d: ", i/5 +1);
			   scanf("%d%d%d%d%d", &ker5[i], &ker5[i+1], &ker5[i+2], &ker5[i+3], &ker5[i+4]);
			}
			conv5x5(x, y, dx, dy, factor, offset, outflag, ker5);
			break;
		case 4:
			getarea();	
			geti("scale factor (power of 2)", &factor);
			geti("offset (0-255)", &offset);
			geti("output mode", &outflag);
			printf("\nenter kernel values separated by a space\n");
			for(i=0;i<49;i +=7){
			   printf("\nline %d: ", i/7 +1);
			   scanf("%d%d%d%d%d%d%d", &ker7[i], &ker7[i+1], 
			   &ker7[i+2], &ker7[i+3], &ker7[i+4], &ker7[i+5], &ker7[i+6]);
			}
			conv7x7(x, y, dx, dy, factor, offset, outflag, ker7);
			break;
		case 5:
			getarea();	
			geti("output mode", &outflag);
			enhoriz(x, y, dx, dy, outflag);
			break;
		case 6:
			getarea();	
			geti("output mode", &outflag);
			envert(x, y, dx, dy, outflag);
			break;
		case 7:
			getarea();	
			geti("output mode", &outflag);
			laplacian(x, y, dx, dy, outflag);
			break;
		case 8:
			getarea();	
			geti("output mode", &outflag);
			lopass(x, y, dx, dy, outflag);
			break;
		case 9:
			getarea();	
			geti("output mode", &outflag);
			sharpen(x, y, dx, dy, outflag);
			break;
		case 10:
			getarea();	
			geti("output mode", &outflag);
			blur(x, y, dx, dy, outflag);
			break;
		case 11:
			getarea();	
			geti("\n color =  ", &color);
			geti("\n bank =   ", &bank);
			histeq(color, bank, x, y, dx, dy);
			break;
		case 12:
			getarea();	
			roberts(x, y, dx, dy);
			break;
		case 13:
			getarea();	
			geti("factor", &factor);
			sobel(x, y, dx, dy, factor);
			break;
		case 14:
			coloredges(0);
			break;		/* taken care of above */
		case 16:
			getarea();	
			geti("threshold", &thresh);
			printf("\nenter logical kernel values separated by a space\n");
			for(i=0;i<9;i +=3){
			   printf("\nline %d: ", i/3 +1);
			   scanf("%d%d%d", &ker3[i], &ker3[i+1], &ker3[i+2]);
			}
			dilate(x, y, dy, dy, thresh, 3, 3, ker3);
			break;
		case 18:
			getarea();	
			geti("x step", &xs);
			geti("y step", &ys);
			geti("binsize", &bsize);
			histogram(x, y, dx, dy, xs, ys, bsize, histarray);
			for(i=0;i<256;i++) 
			    printf("\n value %d: %lx", i, histarray[i]);
			wwait();
			break;
		case 19: 
			swap6();
			break;
		case 20: 
			getarea();	
			geti("\n thresh = ", &thresh);
			printf("\nenter kernel values separated by a space\n");
			for(i=0;i<3;i ++){
			   printf("\nline %d: ", i +1);
			   scanf("%d%d%d", &ker3[i], &ker3[i+1], &ker3[i+2]);
			}
			erode(x, y, dx, dy, thresh, 3, 3, ker3);
			break;
		default:
			break;
		}
	}
}


static int	x1, y1, dx1, dy1, xfact, yfact;
static int	x2, y2, dx2, dy2, x3, y3, dx3, dy3;

menu10()
{
	int		status, multiple, xstart, ystart;
	float	fxf, fyf;

	for (;;) {
		printf("\n***** IMAGE GEOMETRY *****\n");
		printf("\n 0:return to main menu");
		printf("\n 1:squish");
		printf("\n 2:rot90");
		printf("\n 4:ymirror");
		printf("\n 5:zoom");
		printf("\n 6:rotate");
		geti("\nFunction", &option);

		switch (option) {
		case 0:return;
		case 1: 
			geti("\nXstart", &xstart);
			geti("Ystart", &ystart);
			squish(xstart, ystart);
			break;
		case 2:
			getarea();
			geti("# of rotations?", &multiple);
			rot90(x, y, dx, dy, multiple);
			break;
		case 4:
			getarea();
			ymirror(x, y, dx, dy);
			break;
		case 5:
			printf("\nSource area:");
			getarea();
			x1 = x;  y1 = y;  dx1 = dx;  dy1 = dy;
			printf("\nDestination area:");
			getarea();
			geti("X factor (1-255)", &xfact);
			geti("Y factor (1-255)", &yfact);
			repzoom(x1, y1, dx1, dy1, x, y, dx, dy, xfact, yfact);
			break;
		case 6:
			getarea();
			geti("Angle (degrees)", &xfact);
			rotate(x, y, dx, dy, (double)xfact);
			break;
		default:
			break;
		}
	}
}

static char string[255];

menu11()
{
	unsigned int red, green, blue, len;
	int bank, color, radius, size, dir;

	for (;;) {
		printf("\n***** GRAPHICS *****\n");
		printf("\n 0:return to main menu");
		printf("\n 1:wedge");
		printf("\n 2:grid");
		printf("\n 3:circle");
		printf("\n 5:fill");
		printf("\n 6:flood");
		printf("\n 7:rectangle");
		printf("\n 8:block");
		printf("\n 9:text");
		printf("\n10:bitcolor");
		geti("\nFunction", &option);

		switch (option) {
		case 0:
			return;
		case 1:
			wedge();
			break;
		case 2:
			geti("\nX spacing", &x);
			geti("Y spacing", &y);
			geti("Color", &color);
		grid(x, y, color);
			break;
		case 3:
			geti("\nX center", &x);
			geti("Y center", &y);
			geti("Radius", &radius);
			geti("X ratio", &dx);
			geti("Y ratio", &dy);
			geti("Color", &color);
			circle(x, y, radius, dx, dy, color);
			break;
		case 5:
		case 6:
			geti("\nX start", &x);
			geti("Y start", &y);
			geti("Fill color", &color);
			if (option == 5) {
				geti("Border color", &dx);
				fill(x, y, color, dx);
			}
			else
				flood(x, y, color);
			break;
		case 7:
		case 8:
			getarea();
			geti("Color", &color);
			if (option == 7) 
				rectangle(x, y, dx, dy, color);
			else 
				block(x, y, dx, dy, color);
			break;
		case 9:
			geti("\nX start", &x);
			geti("Y start", &y);
			geti("Direction (0-1)", &dir);
			geti("Size (1-20)", &size);
			geti("Color", &color);
			printf("Text string: ");
			scanf("%s", string);
			text(x, y, dir, size, color, string);
			break;
		case 10:
			getu("\nBank", &y);
			getu("\nPosition of RED bits", &red);
			getu("\nPosition of GREEN bits", &green);
			getu("\nPosition of BLUE bits", &blue);
			bitcolor(y, red, green, blue);
			break;
		default:
			break;
		}
	}
}

menu12()
{
	int option, feedbk, video;

	for (;;) {
		printf("\n***** BIT MANIPULATIONS *****\n");
		printf("\n 0:return to main menu");
		printf("\n 1:crystal");
		printf("\n 2:extsync");
		printf("\n 3:fgoff");
		printf("\n 4:fgon");
		printf("\n 5:setcamera");
		printf("\n 6:getcamera");
		printf("\n 7:setinmux");
		printf("\n 8:getinmux");
		geti("\nFunction", &option);

		switch (option) {
		case 0:
			return;
		case 1: 
			crystal();
			break;
		case 2:
			extsync();
			break;
		case 3: 
			fgoff();
			break;
		case 4: 
			fgon();
		break;
		case 5: 
			geti("\nVideo_input", &video);
			setcamera(video);
			break;
		case 6: 
			printf("\nValue = %d", getcamera());
			wwait();
			break;
		case 7: 
			geti("\nFeedback", &feedbk);
		setinmux(feedbk);
			break;
		case 8: 
			printf("\nValue = %d", getinmux());
			wwait();
			break;
		default:
			break;
		}		
	}
}

menu13()
{
	int	option, nframes, delay;
	int	bank, old, new;

	for (;;) {
		printf("\n***** Movies and Real Time *****\n");
		printf("\n 0:return");
		printf("\n 1:makemovie");
		printf("\n 2:playmovie");
		printf("\n 3:rtsubtract");
		printf("\n 4:rtdiffs");
		printf("\n 5:rtedges");
		printf("\n 6:slopass");
		geti("\nFunction", &option);

		switch (option) {
		case 0:
			return;
		case 1: 
			geti("\nFrames", &nframes);
			geti("Delay", &delay);
			makemovie(nframes, delay);
			break;
		case 2: 
			geti("\nFrames", &nframes);
			geti("Delay", &delay);
			playmovie(nframes, delay);
		break;
		case 3: 
			geti("\nBank", &bank);
			rtsubtract(bank);
			break;
		case 4: 
			geti("\nBank", &bank);
			rtdiffs(bank);
			break;
		case 5: 
			geti("\nBank", &bank);
			rtedges(bank);
			break;	
		case 6: 
			geti("\nBank", &bank);
			geti("New", &new);
			geti("Old", &old);
			slopass(bank, old, new);
			break;
		default:
			break;
		}
	}
}