#include "system.h"
#include "tcl_interface.h"




/**** RLEPair.cc 
  Member functions for RLEPairs
  RLEPair functions defined in the function header
  rev 10/20 Kathey Marsden 
*/




RLEPairs::RLEPairs(int rownum)
:List()
{
  numPixels = 0;
  row = rownum;
}


RLEPairs::~RLEPairs()
{
  for (ListElement *ptr = first; ptr != NULL; ptr = ptr->next) {
    if (ptr->item != NULL)
      delete (RLEPair *) (ptr->item);
     }

  while(!IsEmpty())
    Remove();
}

void RLEPairs::print_pairs()
{
  RLEPair* item;
  for (ListElement *ptr = first; ptr != NULL; ptr = ptr->next) {
    item = (RLEPair *)(ptr->item);
    printf("(%d->%d)", item->start, item->end);
  }
  printf("\n");
}

void RLEPairs::draw_pairs(char * window, double scaleFactor,
			  int y_coord, char* color, double width)
{
  RLEPair* item;
  scale(y_coord,scaleFactor);
  for (ListElement *ptr = first; ptr != NULL; ptr = ptr->next) {
    item = (RLEPair *)(ptr->item);
    int line_start = item->start;
    int line_end = item->end;
    scale(line_start,scaleFactor);
    scale(line_end, scaleFactor);
    if(width > 1)
      docommand("%s create line %d %d %d %d -fill %s -width %d", window, 
		line_start, y_coord, line_end, y_coord, color, (int)width);
    else
      docommand("%s create line %d %d %d %d -fill %s", window, line_start, 
		y_coord, line_end, y_coord, color);
  }
}

void RLEPairs::shift(int bits)
/*--------------------------------------------------------------
Primary Purpose: shift a row right by bits
Arguments: bits: the number of bits to shift by
Return Value: none
Effects: ...
Constraints:
Rev: 11/1 AR

Someone should write a macro for this for loop. . .
---------------------------------------------------------------*/
{
  RLEPair* item;
  for (ListElement *ptr = first; ptr != NULL; ptr = ptr->next) {
	  item = (RLEPair *)(ptr->item);
	  item->start += bits;
	  item->end += bits;
	}
}

void RLEPairs::fill(unsigned char * contents, int contentsLength,
		    int contentsRow)
/*--------------------------------------------------------------
Primary Purpose:  Take the contents of a line scanned from a 
TIFF file and put it into this list of RLEPairs
Arguments: contents is the result of a TIFFReadScanline function
           contentsLength is the number of unsigned chars in contents
	   contentsRow is the Row that this interval belongs to
Effects: Scans contents and for each range of black pixels, adds
         an RLEPair to the list
Constraints:
Rev: 10/20 KM  
---------------------------------------------------------------*/
{
  if(contentsRow != row)
    printf("Warning: merging to %d what appears to belong at %d\n", row, contentsRow);

  bool inPair = FALSE;      // Flag set to TRUE when Run of black starts
  short int startCol =0;
  short int endCol = 0;
  short int curCol= 0;
  unsigned char nextChar;

// Deallocate old pairs
  for(ListElement *ptr = first; ptr != NULL; ptr = ptr->next)
    removeAt(ptr);

  for (int c = 0; c < contentsLength; c++)
    {
      nextChar = contents[c];


      if (nextChar == 255)
        {
	  endCol = c*8+7;
	  // If this is a new pair we also have to set  start col
	  if (!inPair)
	    {
	      startCol = c*8;
	      inPair = TRUE;
	    }
	}
      else if(nextChar == 0)
	{
	  if (inPair)
	    {
	      RLEPair * pair = new RLEPair(startCol,endCol, contentsRow);
	      Append(pair);
	      inPair = FALSE;
	      numPixels += endCol - startCol +1;
	    }
	}
      else {  // Start Shifting and look at each bit

	// high bit on left
	for (int i = 7; i >=0; i--)
	  {
	    curCol = 7 + c * 8 - i;
	    /*** Black Pixel handling  */
	    if ((nextChar>>i)&1)      // if this is a black pixel
	      {
		if (!inPair)   // If not in a Pair, Start of a new Pair
		  {
		    inPair = TRUE;
		    startCol = curCol;
		    endCol = curCol;
		  }
		else           // Extend current Pair
		  endCol = curCol;
	      }
	    /*** White Pixel Handling **/
	    else            // This is a white pixel
	      if (inPair)   // Close off the Pair add to the list 
		{
		  RLEPair * pair = new RLEPair(startCol,endCol, contentsRow);
		  Append(pair);
		  inPair = FALSE;
		  numPixels += endCol - startCol+1;
		}
	    // if not in pair just continue
	  }
      }
   }
}


#define DEBUG_PIXELS_BETWEEN 0
int RLEPairs::pixelsBetween(int startCol, int endCol)
/*--------------------------------------------------------------
Return Value:  Returns the number of black pixels between column 
               startCol and column endCol.
Constraints:  0 <= startCol < endCol;  endCol < imageWidth  of RLEMap
Rev: 10/20 KM
---------------------------------------------------------------*/
{
  if (DEBUG_PIXELS_BETWEEN)
      {
	printf("Call to pixels between: start = %d, finish = %d\n", startCol, endCol);
      }
/*  assert(startCol < endCol); */
  if(!(startCol < endCol))
      {
	printf("Warning, startcol %d not less then endcol %d (setting startcol = endcol)\n", startCol, endCol);
	startCol = endCol;
      }

  int count= 0;
  int pairStart;
  int pairEnd;
  RLEPair * item;

  for (ListElement *ptr = first; ptr != NULL; ptr = ptr->next) {
	  item = (RLEPair *)(ptr->item);
      	  pairEnd = item->end;
          pairStart = item->start;
	  // Don't loop anymore if past endCol
	  if (pairStart > endCol) break; 
  
	    // range starts after this pair
	  if (pairEnd < startCol) ; // do nothing
	     // range starts and ends in this pair
	    else if (pairStart <= startCol && pairEnd >= endCol)
	      count += endCol - startCol +1;
	    // range starts in this pair but ends later
	    else if (pairStart <=  startCol && pairEnd <= endCol)
	      count += pairEnd - startCol + 1;
	    // range includes this whole pair
	    else if (pairStart >= startCol && pairEnd <= endCol)     
	      count += pairEnd - pairStart + 1;
	    // range ends in the middle of this pair
	    else 
	      count += endCol - pairStart + 1;

	  // printf(" %d , %d  - %d newcount\n", pairStart, pairEnd, count);
	  }
	    	  


  return count;

}


RLEPairs * RLEPairs::extract(int startCol, int endCol)
/*--------------------------------------------------------------
Primary Purpose: Makes a copy of a sectionn of this row
Arguments: startCol - starting column to extract
           endCol - ending column to extract
Return Value: a pointer to a new RLEPairs that has been
extracted from this.
Constraints: start <= first col of first pair 
             end <= ending col of lat pair
Rev:  KM 11/16
---------------------------------------------------------------*/
{

  int pairStart;
  int pairEnd;

  RLEPair * item;
  RLEPairs * returnPairs = new RLEPairs(row);



  for (ListElement *ptr = first; ptr != NULL; ptr = ptr->next) {
	  item = (RLEPair *)(ptr->item);
      	  pairEnd = item->end;
          pairStart = item->start;
	  row = item->row;

	  // Don't loop anymore if past endCol
	  if (pairStart > endCol) break; 
  
	    // range starts after this pair
	  if (pairEnd < startCol) ; // do nothing

	     // range starts and ends in this pair
	    else if (pairStart <= startCol && pairEnd >= endCol)
		{
          	 RLEPair * addpair = new RLEPair(startCol,endCol, row);
		 returnPairs->Append(addpair);
	       }
	    // range starts in this pair but ends later
	    else if (pairStart <=  startCol && pairEnd <= endCol)
		{
          	 RLEPair * addpair = new RLEPair(startCol,pairEnd, row);
		 returnPairs->Append(addpair);
	       }

	    // range includes this whole pair
	    else if (pairStart >= startCol && pairEnd <= endCol)     
		{
          	 RLEPair * addpair = new RLEPair(pairStart,pairEnd, row);
		 returnPairs->Append(addpair);
	       }
	    // range ends in the middle of this pair
	    else 
		{
          	 RLEPair * addpair = new RLEPair(pairStart,endCol, row);
		 returnPairs->Append(addpair);
	       }	    

	  }
/*  printf("Extract returning: ");
    returnPairs->print_pairs();  */
  return returnPairs;
}



void RLEPairs::merge(RLEPairs * pairs)
/*--------------------------------------------------------------
Primary Purpose: Inserts  the black regions of pairs into this.
Arguments: pairs - RLEPair list to be combined with this one.
Return Value: A new list that represtents merged data
Effects: Modifies this to add pairs. deallocates pairs.
Constraints:
Rev: 11/16/95
---------------------------------------------------------------*/
{
  if((!pairs) || (pairs->length == 0))
    return;

  int pairStart;
  int pairEnd;

  RLEPair * item;
  int lastCol =  ((RLEPair *) (last->item))->end;
  int lastColpairs =  ((RLEPair *) (pairs->last->item))->end;
  if (lastCol < lastColpairs)
     lastCol = lastColpairs;


  int numChars = lastCol/8 + 1;
  uchar buffer[numChars];
  for(int i = 0; i < numChars; i++) buffer[i] = 0;
  
  for (ListElement * ptr2 = pairs->first; ptr2 != NULL; ptr2 = ptr2->next) 
      {
	item = (RLEPair *)(ptr2->item);
	setRange(buffer,  item->start, item->end);
      }
  
  
  for (ListElement * ptr=first; ptr != NULL; ptr = ptr->next) 
	{
	  item = (RLEPair *)(ptr->item);
	  setRange(buffer,  item->start, item->end);
	}

  fill(buffer, numChars, row);

/*  printf("Merged to form: ");
    print_pairs(); */

}