/* Segment.c   
   input depth and left image
   output segmented layer

   */

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/file.h>
#include <stdarg.h>
#include <math.h>

#include "segment.h"

void save2file (unsigned char *p, int nrows, int ncols, char fn[50])
{
  FILE *fp;
  unsigned char *pt;

  int i, j;

  if ( !(fp = fopen (fn, "w")) ) {
    printf ("can't open %s\n", fn);
    exit (1);
  }

  pt = p;

  for (i=0;i<nrows;i++) {
    for (j=0;j<ncols;j++) {

      fprintf (fp,"%d ", (int)(*pt) );
      pt ++;
    }

    fprintf (fp, "\n");
  }

  fclose (fp);
  printf ("%s is written\n",fn);
}

void readfile (unsigned char *p, int nrows, int ncols, char fn[50])
{
  FILE *fp;
  unsigned char *pt;

  int i, j;

  if ( !(fp = fopen (fn, "r")) ) {
    printf ("can't open %s\n", fn);
    exit (1);
  }

  pt = p;

  for (i=0;i<nrows;i++) {
    for (j=0;j<ncols;j++) {

      fscanf (fp,"%uc ", pt );
      pt ++;
    }

    fscanf (fp, "\n");
  }

  fclose (fp);
  printf ("%s is read\n",fn);
}

void histogram (unsigned char *p, unsigned char histo[64])
{
  int i, j;
  unsigned char * pt;

  for (i=0;i<64;i++)
    histo[i] = 0;

  pt = p;

  for (i=0;i<FH;i++) {
    for (j=0;j<FW;j++) {

      if ( *pt < 64 && i<90 && j<110)
	histo[ (int)(*pt) ] ++;
      pt ++;

    }
  }

  printf ("done\n");
}

/* segment input image into blocks */
void segment (unsigned char *left_buf, unsigned char *p, Block * b[MAX_B], int * bn)
{
  unsigned char dbuf[DW*DH];

  int i,j,t;

  t = 0;
  for (i=0;i<DH;i++) {
    for (j=0;j<DW;j++) {
      
      dbuf[t] = p[i*FW + j];
      t ++;
    }
  }

  binarize (dbuf, DH, DW, DEPTH_LOW, DEPTH_HIGH);

  topo_filter (dbuf, DH, DW);

  block_seg1 (dbuf, DH, DW, left_buf, b, bn);

}

void binarize (unsigned char *in, int nrows, int ncols, int t_low, int t_high)
{
  int i,j,t;

  for (i=0;i<nrows;i++) {
    for (j=0;j<ncols;j++) {
      
      t = i*ncols + j;

      if (in[t] >= t_low && in[t] <= t_high) {
	in[t] = 1;
      } else {
	in[t] = 0;
      }

    }
  }

}
  

void topo_filter (unsigned char *p, int nrows, int ncols)
{
  int i, j,k;
  int t0, t[4];
  int flag, n;
  int shift;

  shift = nrows * ncols;

  do {

    flag = 0;
    t0 = 0;

    for (i=0;i<nrows;i++) {
      for (j=0;j<ncols;j++) {

	if ( p[t0] > 0 ) {

	  t[0] = t0 - 1;
	  t[1] = t0 + 1;
	  t[2] = t0 - ncols;
	  t[3] = t0 + ncols;
	
	  n = 0;

	  for (k=0;k<4;k++) {

	    if (t[k] >= 0 && t[k]<shift) {
	      if ( p[t[k]] > 0 )
		n ++;
	    }

	  }

	  if (n<=1) {
	    p[t0] = 0;
	    flag = 1;
	  }
	}

	t0 ++;

      }
    }

  } while (flag);

}

void block_seg (unsigned char *buf, int nrows, int ncols, unsigned char *left, 
		Block * block[MAX_B], int * bn)
{
  int i,j,k,t;

  *bn = 0;

  for (i=DH-1;i>BB;i-=BB) {
    for (j=10;j<DW;j++) {

      t = i*DW + j;

      if (buf[t] == 1) {

	block[(*bn)] = (Block *)malloc (sizeof (Block));
	if (block[(*bn)] == NULL) {
	  printf ("malloc error\n");
	  exit (1);
	}

	/*	fill_block (left, block[(*bn)], i,j); */
      
	*bn ++;

	j+=BB-1;

      }
    }
  }
}

/* find the largest one */
void block_seg1 (unsigned char *buf, int nrows, int ncols, unsigned char *left_buf, 
		Block * block[MAX_B], int * bn)
{
  int i,j,t;
  int top, left, right, len;

  left = DW;
  right = 0;
  top = DH;

  for (i=1;i<DH-1;i++) {

    t = i*ncols;

    for (j=0;j<DW;j++) {
      
      len = 0;

      while (buf[t+j]>0 && j<DW) {
	len ++;
	j ++;
      }

      if (len > 10) {

	if (top>i) top = i;
	if (right < j) right = j;
	if (right-len<left) left = right - len;

	break;
      }
    }
  }	

  if (right - left < 10) {
    printf ("******************* no object ******************\n");
    block[0] = NULL;
    *bn = 0;
    return;
  }

  *bn = 1;
  
  block[(*bn)-1] = (Block *)malloc (sizeof(Block));

  if (block[(*bn)-1] == NULL) {
    printf ("block malloc error");
    exit(1);
  }

  printf ("in depth %d %d %d\n", top, left, right);

  block[(*bn)-1]->ncols = ((right - left)%2==0)?right-left:right-left+1;

  top += 20;
  left += 32;

  block[(*bn)-1]->left = left%2==0?left:left-1;
  block[(*bn)-1]->top = (top - 20)%2==0?top-20:top-19;
  block[(*bn)-1]->nrows = FH - block[(*bn)-1]->top;

  block[(*bn)-1]->buf = (unsigned char *)malloc (block[(*bn)-1]->nrows * block[(*bn)-1]->ncols);

  if (block[(*bn)-1]->buf == NULL) {
    printf ("block->buf null");
    exit (1);
  }

  printf ("%d %d %d %d\n", block[0]->left, block[0]->top, block[0]->nrows, block[0]->ncols);
  
  fill_block (left_buf, block[(*bn)-1]);

}


void fill_block (unsigned char *left_buf, Block * block)
{
  int i,j,k1, k2;

  k1 = block->top * FW + block->left;
  k2 = 0;

  for (i=0;i<block->nrows;i++) {
    for (j=0;j<block->ncols;j++) {

      /*      block->buf[k2] = left_buf[(block->top+i)*FW + block->left + j]; */
      block->buf[k2] = left_buf[k1];
      k2 ++; 
      k1 ++;

    }
    k1 += FW - block->ncols; 
  }

}