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

		         L U T S . C 
***************************************************************************/
/*  Filename : luts.c
 *  purpose  : luts.c does most of the lut loading for this system.
***************************************************************************/

#include </sys/h/types.h>
#include </usr/include/curses.h>
#include <stdio.h>

extern WINDOW *funcwin;
extern int white_piece;
extern int inverse_isthmus;

int i;

/************************************************************************** 
                        initluts 
***************************************************************************/
initluts()
{
  int lut_values[256];
  for(i=0;i<256;i++)  /* LINEAR LUT */
     lut_values[i] = i;
  VIS$LOAD_LUT(0, 0, lut_values);
  VIS$LOAD_LUT(1, 0, lut_values);
  VIS$LOAD_LUT(2, 0, lut_values);
  VIS$LOAD_LUT(3, 0, lut_values);

  for(i=0;i<256;i++)
     lut_values[i] = (i < 128 ) ? 0:1;
  VIS$LOAD_LUT(0, 1, lut_values);
  
  for(i=0;i<256;i++)
     lut_values[i] = (i < 128 ) ? 0:255;
  VIS$LOAD_LUT(1, 1, lut_values);
  VIS$LOAD_LUT(2, 1, lut_values);
  VIS$LOAD_LUT(3, 1, lut_values);
  
  for(i=0;i<256;i++)
     lut_values[i] = 12 /*4 was red changed to white*/ ;
  VIS$LOAD_LUT(0, 3, lut_values);
  VIS$LOAD_LUT(1, 2, lut_values);
  VIS$LOAD_LUT(2, 2, lut_values);
  VIS$LOAD_LUT(3, 2, lut_values);


  for(i=0;i<256;i++)
     switch(i)
     {
       case 1 : lut_values[i] = 0;
                break;
       case 2 : lut_values[i] = 255;
                break;
       case 3 : lut_values[i] = 0;
                break;
       case 4 : lut_values[i] = 255;
                break;
       case 5 : lut_values[i] = 0;
                break;
       case 6 : lut_values[i] = 0;
                break;
       case 7 : lut_values[i] = 255;
                break;
       case 8 : lut_values[i] = 175;
                break;
       case 9 : lut_values[i] = 155;
                break;
       case 10 : 
		lut_values[i] = 75;
                break;
       case 11 : lut_values[i] = 175;
                break;
       case 12 : lut_values[i] = 255;
                break;
       default: lut_values[i] = 0;
                break;
     }
   VIS$LOAD_LUT(1, 3, lut_values);
  
   for(i=0;i<256;i++)
     switch(i)
     {
       case 1 : lut_values[i] = 0;
                break;
       case 2 : lut_values[i] = 255;
                break;
       case 3 : lut_values[i] = 0;
                break;
       case 4 : lut_values[i] = 0;
                break;
       case 5 : lut_values[i] = 255;
                break;
       case 6 : lut_values[i] = 0;
                break;
       case 7 : lut_values[i] = 175;
                break;
       case 8 : lut_values[i] = 200;
                break;
       case 9 : lut_values[i] = 50;
                break;
       case 10 : lut_values[i] = 250;
                break;
       case 11 : lut_values[i] = 150;
                break;
       case 12 : lut_values[i] = 255;
                break;
       default: lut_values[i] = 0;
                break;
     }
    VIS$LOAD_LUT(2, 3, lut_values);
   
   for(i=0;i<256;i++)
     switch(i)
     {
       case 1 : lut_values[i] = 0;
                break;
       case 2 : lut_values[i] = 255;
                break;
       case 3 : lut_values[i] = 255;
                break;
       case 4 : lut_values[i] = 0;
                break;
       case 5 : lut_values[i] = 0;
                break;
       case 6 : lut_values[i] = 255;
                break;
       case 7 : lut_values[i] = 200;
                break;
       case 8 : lut_values[i] = 100;
                break;
       case 9 : lut_values[i] = 100;
                break;
       case 10 : lut_values[i] = 50;
                break;
       case 11 : lut_values[i] = 150;
                break;
       case 12 : lut_values[i] = 255;
                break;
       default: lut_values[i] = 0;
                break;
     }
    VIS$LOAD_LUT(3, 3, lut_values);
 }

do_mode1()
{ 
  int lut_values[256];
   colors(1); 
   lut_values[0] = 0;
   for(i=1;i<256;i++)
      lut_values[i] = (i / 35) + 1;
   VIS$LOAD_LUT(0, 1, lut_values);
   VIS$SET_MODE(1);
   VIS$FREEZE(); 
}

init_binarize(threshold)
 int threshold;
{
   int lut_values[256];
   for (i=0; i<256; i++)
   {
      if (white_piece)
         lut_values[i] = (i < threshold) ? 0:1;
      else
         lut_values[i] = (i < threshold) ? 1:0; /* was 80 */
   }
   VIS$LOAD_LUT(0, 2, lut_values);
 }
 
 do_inverse(threshold) 
  int threshold;
 {
    int lut_values[256];
    for (i=0; i<256; i++)
    {
       if (white_piece)
	  lut_values[i] = (i < threshold) ? 1:0; /* was 200 */
       else
          lut_values[i] = (i <  threshold ) ? 0:1; /* was 100 */
    }
  /* inverse binarize--1 for background (white) 0 for object (black) */
  VIS$LOAD_LUT(0, 2, lut_values);
 }

#ifdef ROGER
medial_mode()
{
  int i, lut_values[256];
   printf ("in medial mode \n");   
   
   VIS$SET_MODE(1);
   lut_values[0] = 0;
   if (inverse_isthmus)
      lut_values[255] = 254;
   else
      lut_values[255] = 255;
   lut_values[254] = 254;
   for(i=1;i<254;i++)
      lut_values[i] = 254;
   VIS$LOAD_LUT(0, 4, lut_values);
   sleep(1);
   VIS$FREEZE(); 
   printf ("out of medial mode \n");   
}
#endif

thin ( grey)
int grey;
{
   int i;
   int lut_values[256];
   lut_values[0] = 0;
   for(i=1;i<256;i++)
      lut_values[i] = i;
   lut_values[grey] = 254;
   VIS$LOAD_LUT(0, 1, lut_values);
   VIS$SET_MODE(1);
   VIS$FREEZE(); 
}

redscrn()
{
  VIS$INIT_FB();
  VIS$INIT_LUTS();
  initluts(); 

  VIS$SELECT_LUT(0,3);
  VIS$SELECT_LUT(1,3);
  VIS$SELECT_LUT(2,3);
  VIS$SELECT_LUT(3,3);
  VIS$VIEW();
  VIS$FREEZE();
}

euclid_lut(max_elevation, interval)
  int max_elevation;
  int interval;
{
  int i, num_intervals, sub, incr;
  int lut_values[256]; 
#ifdef ROGER
  for(i=0;i<256;i++)  /* distance LUT */
  {   lut_values[i] = i - (i % interval /*16*/);
  }
#endif  
 if (interval <= max_elevation)
 {
  num_intervals = max_elevation / interval; 
  incr = 255 / num_intervals; 
  for(i=0;i<256;i++)  /* distance LUT */
  {
      sub = (int)(i / interval) * incr;
      lut_values[i] =  (i < max_elevation) ? sub : 255/* i??*/;
  }
  VIS$LOAD_LUT(1, 14, lut_values);
  VIS$LOAD_LUT(2, 14, lut_values);
  VIS$LOAD_LUT(3, 14, lut_values);
 }/* endif */
}

lut_roger(max_elevation)
  int max_elevation;
{
  int i, num_intervals, sub, incr;
  int lut_values[256]; 
  int interval = 20;
  do
  {
   wmove(funcwin,19,15);
   waddstr(funcwin,"Enter interval value 0 to quit=> ");
   wrefresh(funcwin);
   wscanw(funcwin,"%d",&interval);
   wrefresh(funcwin);
   wmove(funcwin,19,15);
   waddstr(funcwin,"                                   ");
   wrefresh(funcwin);
   if (interval > 0)
   if (interval <= max_elevation && interval > 0)
   {
      num_intervals = (int)(max_elevation / interval); 
      incr = (int)(255 / num_intervals); 
      for(i=0;i<256;i++)  /* distance LUT */
      {
      	sub = (int)(i / interval) * incr;
      	lut_values[i] =  (i < max_elevation) ? sub : 255;
  	}
  	VIS$LOAD_LUT(1, 13, lut_values);
  	VIS$LOAD_LUT(2, 13, lut_values);
  	VIS$LOAD_LUT(3, 13, lut_values);
    }/* endif */
 
 } while (interval > 0); 
 wrefresh(funcwin);
}

try_color_lut(funcwin, max_elevation)
  WINDOW *funcwin;
  int max_elevation;
{
  int i, num_intervals, sub, incr;
  int lut_values[256]; 
  int interval = 20;
  do
  {
   wmove(funcwin,19,15);
   waddstr(funcwin,"Enter interval value => ");
   wrefresh(funcwin);
   wscanw(funcwin,"%d",&interval);
   wrefresh(funcwin);
   wmove(funcwin,19,15);
   waddstr(funcwin,"                               ");
   wrefresh(funcwin);
   if (interval == 0)
     return(0);
#ifdef ROGER
  for(i=0;i<256;i++)  /* distance LUT */
  {   lut_values[i] = i - (i % interval /*16*/);
  }
#endif  
   colors(interval);
 } while (interval != 0);
}
/****************************************************************************
    These procedures load the output lut with contrasting colors
    beside one another in the order of black, red, white, blue,
    and green.  As the grey shades increase, a variable is added to
    each of these colors to change them to a variety of other colors.
****************************************************************************/
/*****************************************************************************
                              COLORS 
*****************************************************************************/
colors(thickness)
int thickness;
{
   int i,j,n;
   int redval[256];
   int blueval[256];
   int greenval[256];

   j = 0;
   redval[0] = 0;
   blueval[0] =  0;
   greenval[0] = 0;
   for (i=1; i<=255; i++)
   {
     switch (((i-1)/thickness) % 5)          
     { case 1: /* was 1 = blue */ 
	      redval[i] = 255;
              blueval[i] = 255 /*255*/;
	      greenval[i] = 255 /*255*/;
	      break;
       case 0: /* was 0 = white */
	      redval[i] = 0 /*255*/;
              blueval[i] = 255 /*0*/;
	      greenval[i] = 0 /*255*/;
              break;
       case 2: /* red  */
	      redval[i] = 255 /*0*/;
              blueval[i] = 0 /*255*/;
	      greenval[i] = 0;
              break;
       case 3: /* green */ 
	      redval[i] = 0;
              blueval[i] = 0;
	      greenval[i] = 255;
	      break;
      case 4: /* RWW color */ 
	      redval[i] = 75;
              blueval[i] =  250;
	      greenval[i] = 50;
	      break;

       default: break;
       }
         
    }
   
    redval[255] = 255; /* set to white the last one */
    blueval[255] =  255;
    greenval[255] = 255;
	     /* special to see and debug color */ 
    
    redval[254] = 45;
    blueval[254] = 70;
    greenval[254] = 70;
#ifdef ROGER
    redval[254] = 255; /*45;*/
    blueval[254] = 255; /* 70; */
    greenval[254] = 255; /*70; */
#endif
    
    redval[253] = 45;
    blueval[253] = 70;
    greenval[253] = 70;
    
  
  /* SELECTS THE FOURTH OUTPUT LUT IN FG101/640-2 BOARDS */
  VIS$LOAD_LUT(1, 4, redval);
  VIS$LOAD_LUT(2, 4, greenval);
  VIS$LOAD_LUT(3, 4, blueval);
}

skel_luts(thickness)
int thickness;
{
   int i,j,n;
   int redval[256];
   int blueval[256];
   int greenval[256];

   j = 0;
   redval[0] = 0;
   blueval[0] =  0;
   greenval[0] = 0;
   for (i=1; i<=255; i++)
   {
   switch (((i-1)/thickness) % 5)          
     { case 0: /* red */
	      redval[i] = 255 /*255*/;
              blueval[i] = 255 /*0*/;
	      greenval[i] = 255 /*255*/;
              break;
       case 1: /* white */ 
	      redval[i] = 255;
              blueval[i] = 0 /*255*/;
	      greenval[i] = 0 /*255*/;
	      break;
       case 2: /* blue */
	      redval[i] = 0 /*0*/;
              blueval[i] = 255 /*255*/;
	      greenval[i] = 0;
              break;
       case 3: /* green */ 
	      redval[i] = 0;
              blueval[i] = 0;
	      greenval[i] = 255;
	      break;
      case 4: /* RWW color */ 
	      redval[i] = 75;
              blueval[i] =  250;
	      greenval[i] = 50;
	      break;
      default: break;
       }
         
    }
   
    redval[255] = 255; /* set to white the last one */
    blueval[255] =  255;
    greenval[255] = 255;
	     /* special to see and debug color */ 
    redval[254] = 45;
    blueval[254] = 70;
    greenval[254] = 70;
#ifdef ROGER
    redval[254] = 255; /*45;*/
    blueval[254] = 255; /* 70; */
    greenval[254] = 255; /*70; */
#endif
    
    redval[253] = 45;
    blueval[253] = 70;
    greenval[253] = 70;
  
  /* SELECTS THE 14th OUTPUT LUT IN FG101/640-2 BOARDS */
  VIS$LOAD_LUT(1, 12, redval);
  VIS$LOAD_LUT(2, 12, greenval);
  VIS$LOAD_LUT(3, 12, blueval);
}
/**************************************************************************/
/*                          END SECTION                                   */
/**************************************************************************/