/* Arquivo com funcoes para realizar a segmentacao de retas no
   espaco */

#include <sys/time.h>
#include <sys/resource.h>
#include <stdio.h>
#include <math.h>
#include <string.h>

#define SIZEX 512.0
#define SIZEY 512.0
#define NULL 0
#define ERR  -1
#define OK   1

#define DIM 3  /* ptos com DIM dimensoes o que implica em matrizes
		  de nptos por DIM */

double start, stop;  /* variaveis para contagem de tempo */
double t1=0, t2=0, t3=0, t4=0; /* idem */

float foco, baseline, const_cord_x, const_cord_y;

float amad = 4.0,
      cres = 16.0,
      gera = 12.0;

float erro_pixel; /* erro devido resolucao */
int num_total_ptos = 0, /* num de ptos incluidos em retas */
    num_total_retas = 0; /* numero de retas aceitas */
int   n_reta;     /* numero de pontos minimo para considerar
		         uma reta */

char entrada_iso_casa[50];  /* arquivo com ptos iso para segmentacao */
FILE *seg_reais_2d, *seg_reais_3d, *seg_iso; /* arquivos de saida */



struct reta_ptos{
    int            indice_pto; /* indice do pto na matriz de ptos */
    struct reta_ptos *next;    /* aponta para o proximo pto */
    struct reta_ptos *prev;    /* aponta para o pto anterior */
                };


struct candidato{
    int              nptos; /* num de ptos na reta candidata  */
    float            valor; /* valor da reta candidata    */
    struct candidato *next, /* aponta para o proximo candidato */
                     *prev; /* aponta para o candidato anterior */
    struct reta_ptos *ptr_reta; /* aponta para o inicio da lista */
				/* dos ptos da reta candidata */
		};

struct reta_adulta{
    float       x_ini_iso, /* coordenadas do inicio do segmento */
                y_ini_iso,
		z_ini_iso;
    float       x_fim_iso, /* coordenadas do fim do segmento */
                y_fim_iso,
		z_fim_iso;		
    float       qualidade;    /* tamanho da reta */
    int         nptos;
    struct reta_adulta *next;  /* aponta para a proxima reta adulta */
		};

struct reta_adulta *ini_reta_adulta = NULL,
                   *fim_reta_adulta = NULL;

struct candidato *ini_cand = NULL,
                 *fim_cand = NULL;
struct reta_ptos *ptr_reta_ptos = NULL;

double now(void) 
  { struct rusage ru;
    
    getrusage(RUSAGE_SELF, &ru);
    return(((double)ru.ru_utime.tv_sec)*1000000.0 + ((double)ru.ru_utime.tv_usec));
  }

/* ----funcao para ordenar em ordem crescente um vetor de valores e
   um respectivo vetor de inteiros */
void sort(int n, float value[], int elem[])
  { int p, q, r, mx;
    float cc, vmax;
    int ccelem;
        
    /* 1. Build heap with largest element at value[0] */
    for (p = 0; p<n; p++)
      { cc = value[p]; 
	ccelem = elem[p];
	r = p;
	while(r > 0)
	  { q = (r-1) / 2;
	    if (value[q] < cc) 
	      { value[r] = value[q]; 
		elem[r] = elem[q];
	      }
	    else break;
	    r = q;
	  }
	value[r] = cc; 
	elem[r] = ccelem;
      }

    /* 2. Remove elements from heap and insert at end */
    for (p = n-1; p > 0; p--)
      { 
	/* save value[p] */
	cc = value[p]; 
	ccelem = elem[p];
	/* Move largest heap element to povalue[p] */
	value[p] = value[0]; 
	elem[p] = elem[0];
	/* Insert cc in remaining heap, from root down  */
	q = 0;
	while(1)
	  {
	    value[q] = cc; 
	    elem[q] = ccelem;
	    r = 2*q+1;
	    /* Find largest among cc, value[LEFT(q)], value[RIGHT(q)]  */
	    mx = q; vmax = cc;
	    if ((r<p)&&(value[r]>vmax))
	      { mx = r; vmax = value[r]; }
	    r++;
	    if((r<p)&&(value[r]>vmax))
	      { mx = r; vmax = value[r]; }
	    /*  See who won  */
	    if (mx==q) break;
	    /*  Promote child and advance  */
	    value[q] = value[mx];  
	    elem[q] = elem[mx]; 
	    q = mx;
	  }
      }
  }



/* baricentro - calcula o baricentro dos ptos e os deslocam
                em relacao ao baricentro.  */
void baricentro(m_3d, centro, nptos)
float **m_3d;  /* matriz(n x 3) de entrada e saida dos pontos; n=nptos */
int nptos;     /* num. de linhas da matriz de entrada */
float *centro; /* retorna um vetor[3] dos ptos do centro */
{
 int i, j;

 for(j=0; j<DIM; j++)
   {
     centro[j] = 0.0;
   }
 
 for(i=0; i<nptos; i++)
   {
     for(j=0; j<DIM; j++)
       {
	 centro[j] += (m_3d[i][j] / nptos);
       }
   }

 for(i=0; i<nptos; i++)
   {
     for(j=0; j<DIM; j++)
       {
	 m_3d[i][j] = m_3d[i][j] - centro[j];
       }
   }
} 


/* mult_t - faz a multiplicacao da transposta por sua matriz(n x 3) */
void mult_t(m_3d, m_3x3, nptos)
float **m_3d;   /* matriz de entrada (n x 3) */
float **m_3x3;  /* retorna matriz (3 x 3) saida da multiplicacao */
int nptos;      /* num. de linhas da matriz de entrada */
{
 int i, j, k;

 for(i=0; i<DIM; i++)
   for(j=0; j<DIM; j++)
     m_3x3[i][j] = 0.0;

 for(k=0; k<DIM; k++)
   {
     for(j=0; j<DIM; j++)
       {
	 for(i=0; i<nptos; i++)
	   {
	     m_3x3[k][j] += (m_3d[i][k] * m_3d[i][j]);
  	   }
       }
   }
}


#define NMAX 3  /* para o caso de matrizes 3x3 */
/* auto_jacob - calcula os autovetores e autovalores de uma matriz
                simetrica pelo metodo Jacobiano */
int auto_jacob(a,n,d,v,nrot)
float **a;  /* matriz simetrica de entrada */
int n;      /* tamanho da matriz de entrada */
float *d;   /* retorna vetor com os n autovalores de a */
float **v;  /* retorna matriz que possui nas colunas os autovetores
	       normalizados de a */
int *nrot;  /* retorna o numero de rotacoes de Jacobi requeridas */
{
 int j, iq, ip, i;
 float tresh, theta, tau, t, sm, s, h, g, c;
 float b[NMAX], z[NMAX];

 for(ip=0; ip<n; ip++)
   {
     for(iq=0; iq<n; iq++)
       {
	 v[ip][iq] = 0.0;
       }
     v[ip][ip] = 1.0;
   }
 
 for(ip=0; ip<n; ip++)
   {
     b[ip] = a[ip][ip];
     d[ip] = b[ip];
     z[ip] = 0.0;
   }

 *nrot = 0;

 for(i=1; i<=50; i++)
   {
     sm = 0.0;
     for(ip =0; ip<(n-1); ip++)
       {
	 for(iq=ip+1; iq<n; iq++)
	   {
	     sm += fabs(a[ip][iq]);
	   }
       }

     if(sm == 0.0) return(0);
     if(i < 4)
       tresh = 0.2*sm/(n*n);
     else
       tresh = 0.0;

     for(ip = 0; ip<(n-1); ip++)
       {
	 for(iq = ip+1; iq<n; iq++)
	   {
	     g = 100.0*fabs(a[ip][iq]);
	     if((i>4)&&((fabs(d[ip])+g) == fabs(d[ip]))&&
		       ((fabs(d[iq]+g) == fabs(d[iq]))))
		   a[ip][iq] = 0.0;
	      else
		{
		  if(fabs(a[ip][iq])>tresh)
		    {
		      h = d[iq] - d[ip];
		      if((fabs(h)+g) == fabs(h))
			t = a[ip][iq]/h;
		      else
			{
			  theta = 0.5*h/a[ip][iq];
			  t = 1.0/(fabs(theta)+sqrt(1.0+theta*theta));
			  if(theta < 0.0)
			    t = -t;
		        }

		      c = 1.0/sqrt(1.0+t*t);
		      s = t*c;
		      tau = s/(1.0+c);
		      h = t*a[ip][iq];
		      z[ip] -= h;
		      z[iq] += h;
		      d[ip] -= h;
		      d[iq] += h;
		      a[ip][iq] = 0.0;

		      for(j=0; j<=(ip-1); j++)
			{
			  g = a[j][ip];
			  h = a[j][iq];
			  a[j][ip] = g-s*(h+g*tau);
			  a[j][iq] = h+s*(g-h*tau);
		        }

		      for(j=ip+1; j<=(iq-1); j++)
			{
			  g = a[ip][j];
			  h = a[j][iq];
			  a[ip][j] = g-s*(h+g*tau);
			  a[j][iq] = h+s*(g-h*tau);
		        }


		      for(j=iq+1; j<n; j++)
			{
			  g = a[ip][j];
			  h = a[iq][j];
			  a[ip][j] = g-s*(h+g*tau);
			  a[iq][j] = h+s*(g-h*tau);
		        }

		      for(j=0; j<n; j++)
			{
			  g = v[j][ip];
			  h = v[j][iq];
			  v[j][ip] = g-s*(h+g*tau);
			  v[j][iq] = h+s*(g-h*tau);
		        }

		      (*nrot)++;

		    }
	        }
	    
	   }
       }
   }

 for(ip=0; ip<n; ip++)
   {
     b[ip] += z[ip];
     d[ip] = b[ip];
     z[ip] = 0.0;
   }

 fputs(" 50 interacoes nao devem ocorrer ( JACOBI)\n",stdout);
 return(0);
}
    

/* vet_sort - ordena os auto_vetores na ordem descendente com
              relacao aos respectivos autovalores. */
void vet_sort(d, v, n)
float *d;   /* vetor de entrada dos n autovalores da matriz, e saida
	       dos autovalores ordenados*/
float **v;  /* matriz de entrada que possui nas colunas os autovetores
	       normalizados de a, e saida ordenada dos autovetores */
int n;      /* tamanho da matriz de entrada. */
{
 int k, i, j;
 float p;

 for(i=0; i<(n-1); i++)
   {
     k = i;
     p = d[i];

     for(j=i+1; j<n; j++)
       {
	 if(d[j]>=p)
	   {
	     k = j;
	     p = d[j];
	   }
       }

     if(k!=i)
       {
	 d[k] = d[i];
	 d[i] = p;
	 for(j=0; j<n; j++)
	   {
	     p = v[j][i];
	     v[j][i] = v[j][k];
	     v[j][k] = p;
	   }
       }
   }
}
	     

/* var_perp - calcula a variancia na direcao perpendicular a direcao
              de variancia maxima.
	      Retorna o valor da variancia calculada. */
float var_perp(m_3d, var_para, nptos)
float **m_3d;   /* matriz de entrada (n x 3) */
float var_para; /* variancia na direcao paralela */
int nptos;      /* num. de linhas da matriz de entrada */
{
 int i, j;
 float var_perp,  /* variancia na direcao perpendicular */
       prod;      /* somatorio dos produtos escalares */

 var_perp;
 prod = 0.0;
 
 for(i=0; i<nptos; i++)
   {
     for(j=0; j<DIM; j++)
       {
	 prod += (m_3d[i][j] * m_3d[i][j]);
       }
   }

 var_perp = prod/(nptos-2) - var_para;

 return(var_perp);
}


/* dist() - calcula a distancia entre dois ptos no espaco.
            Retorna a distancia calculada.   */
float dist(p1, p2)
float *p1,  /* ponto 1 ; vetor[3] */
      *p2;  /* ponto 2 ; vetor[3] */
{
 float dist = 0.0;  /* distancia entre p1 e p2  */
 int i;

 for(i=0; i<3; i++)
   {
     dist += (p1[i] - p2[i]) * (p1[i] - p2[i]);
   }

 dist = sqrt(dist);

 return(dist);
}


void ver(m,npontos)
int npontos;
float **m;
{
  int i, j;
  fprintf(stderr,"\n");
  for(i = 0; i<npontos; i++)
    {
      for(j=0; j<3; j++)
	{
	  fprintf(stderr,"   %f",m[i][j]);
        }

      fprintf(stderr,"\n\n");
    }
}

/* funcao conversao de iso para 3d */
void conv_iso_3d(x_iso, y_iso, z_iso, x_3d, y_3d, z_3d)
float x_iso, y_iso, z_iso;
float *x_3d, *y_3d, *z_3d;
{
  *x_3d = baseline * (x_iso - const_cord_x)/(2.0*z_iso);
  *y_3d = baseline * (y_iso*1.414214 - const_cord_y)/(2.0*z_iso);
  *z_3d = foco*baseline/(2.0*z_iso);
}  


/* funcao conversao de 3d para iso */
void conv_3d_iso(x_3d, y_3d, z_3d, x_iso, y_iso, z_iso)
float *x_iso, *y_iso, *z_iso;
float x_3d, y_3d, z_3d;
{
  *z_iso = foco*baseline/(2.0*z_3d);
  *x_iso = 2.0*(*z_iso)*x_3d/baseline + const_cord_x;
  *y_iso = 1.414214*(*z_iso)*y_3d/baseline + 0.707107*const_cord_y;
}  
  


/* ------------- s e g m e n t ------------*/


int ins_candidato(void)
{
  struct candidato *ptr;

  ptr = (struct candidato *)malloc(sizeof(struct candidato));

  if( ptr == NULL)
    {
      fputs(" Erro na insercao de estruturas candidato. \n",stdout);
      return(ERR);
    }

  if( ini_cand == NULL)
    {
      ini_cand = ptr;
      ini_cand->prev = NULL;
    }

  else
    {
      ptr->prev = fim_cand;
      fim_cand->next = ptr;
    }

  fim_cand = ptr;
  fim_cand->next = NULL;

  return(OK);
}


int ins_reta_adulta(void)
{
  struct reta_adulta *ptr;

  ptr = (struct reta_adulta *)malloc(sizeof(struct reta_adulta));

  if( ptr == NULL)
    {
      fputs(" Erro na insercao de estruturas reta_adulta. \n",stdout);
      return(ERR);
    }
    

  if( ini_reta_adulta == NULL)
    {
      ini_reta_adulta = ptr;
    }

  else
    {
      fim_reta_adulta->next = ptr;
    }

  fim_reta_adulta = ptr;
  fim_reta_adulta->next = NULL;

  return(OK);
}


struct reta_ptos *ins_reta_ptos(struct reta_ptos *ptr_ant, struct candidato *ptr_cand) /* ptr_ant = aponta pro ponto anterior da mesma reta.
           ptr_cand = aponta pra estrutura candidata 
	   
	   retorna o ponteiro para oponto */
{
  struct reta_ptos *ptr;

  ptr = (struct reta_ptos *)malloc(sizeof(struct reta_ptos));

  if( ptr == NULL)
    {
      fprintf(stdout," Erro na insercao de estruturas reta_ptos. \n");
      return(NULL);
    }
  if(ptr_ant == NULL)  /* primeiro da lista  */
    {
	ptr->prev = NULL;
	ptr_cand->ptr_reta = ptr;
    }
  else
    {
	ptr_ant->next = ptr;
	ptr->prev = ptr_ant;
    }

  ptr->next = NULL;
  
  return(ptr);
}

/* elimina estrutura candidato */
void del_candidato(struct candidato *ptr_cand)
{
    struct candidato *ptr_cand_aux;
    struct reta_ptos *ptr_ptos, *ptr_ptos_aux;

    ptr_cand_aux = ptr_cand->prev;
    if(ptr_cand_aux == NULL)
      {
	  ptr_cand_aux = ptr_cand->next;
	  ini_cand = ptr_cand_aux;
	  if(ptr_cand_aux == NULL)
	    {
		fim_cand = NULL;
	    }
	  else
	    {
		ptr_cand_aux->prev = NULL;
	    }
      }
    else
      {
	  ptr_cand_aux->next = ptr_cand->next;
	  
	  ptr_cand_aux = ptr_cand->next;
	  if(ptr_cand_aux == NULL)
	    {
		fim_cand = ptr_cand->prev;
	    }
	  else
	    {
		ptr_cand_aux->prev = ptr_cand->prev;
	    }
      }

    if(ptr_cand->ptr_reta != NULL)
      {
	  ptr_ptos = ptr_cand->ptr_reta;
	  
	  while(ptr_ptos)
	    {
		ptr_ptos_aux = ptr_ptos;
		ptr_ptos = ptr_ptos->next;
		free(ptr_ptos_aux);
	    }	  
      }
	  
    free(ptr_cand);
}

/* elimina ptos de uma estrutura candidato */
void del_reta_ptos(struct reta_ptos *ptr, struct candidato *ptr_cand)
{
    struct reta_ptos *ptr_aux;

    if(ptr->prev == NULL)  /* primeiro da lista */
      {
	  ptr_cand->ptr_reta = ptr->next;
	  if(ptr->next == NULL)  /* unico da lista */
	    {
		free(ptr);
		return;
	    }
	  ptr_aux = ptr->next;
	  ptr_aux->prev = NULL;
      }
    else
      {
	  if(ptr->next == NULL) /*ultimo da lista */
	    {
		ptr_aux = ptr->prev;
		ptr_aux->next = NULL;
	    }
	  else  /* meio da lista */
	    {
		ptr_aux = ptr->prev;
		ptr_aux->next = ptr->next;
		ptr_aux = ptr->next;
		ptr_aux->prev = ptr->prev;
	    }
      }
    free(ptr);
    return;
}
	  

/* gera_cand() - procura os pares de ptos mais proximos
                 escreve os ptos na lista de ptos da reta candidata */
void gera_cand(mpt, nptos)
int nptos;    /* num de ptos no espaco  */
float **mpt;  /* matriz (nptos x 3) dos ptos no espaco */
{
 int i, j, num_candidatos, t, ind;
 float dmin, d;
 struct candidato *ptr_cand;
 struct reta_ptos *ptr_reta1, *ptr_reta2;

 num_candidatos = 0;
 for(i=0; i<nptos; i++)
   {
         
     j = 0;
     if(i == 0)
         j = 1;
     
     dmin = dist(mpt[i], mpt[j]);
     
     for(j=1; j<nptos; j++)
       {
	 if(i != j)
	   {
	     d = dist(mpt[i], mpt[j]);
	     if(d < dmin)
	       {
	         ind = j;
		 dmin = d;
	       }
	   }
       }
       
     
     if(dmin<gera*erro_pixel)
       {
	 t=ins_candidato();
	 if(t==ERR)
	   fputs(" Erro na insercao de estruturas candidato \n",stdout);
	   
	 fim_cand->ptr_reta = NULL;
	 
	 ptr_cand = fim_cand;
	 
	 ptr_reta1 = ins_reta_ptos(ptr_cand->ptr_reta, ptr_cand);
	 ptr_reta2 = ins_reta_ptos(ptr_reta1, ptr_cand);
	 ptr_reta1->indice_pto = i;
	 ptr_reta2->indice_pto = ind;
	 
	 ptr_cand->nptos = 2;
	 ptr_cand->valor = dmin;
	 num_candidatos++;
       }
   }
 fprintf(stdout," Numero de candidatos iniciais = %d\n",num_candidatos);
}


/* val_reta() - calcula o fator(valor) da reta aproximada no espaco
                retorna o valor calculado  */
float val_reta(mat, npt)
float **mat;  /* matriz auxiliar utilizada no calculo de altovalores*/
int npt;  /* num de linhas(ptos) na matriz mat */
{
 float *m3x3[3], *autovetor[3], **ma2;
 float autovalor[3], baric[3];
 float var_para, /* variancia paralela a direcao de maior autovalor */
       var_per,  /* variancia perpendicular */
       val_reta; /* valor da reta  */
 int i, j, nrot;

 m3x3[0] = (float *)malloc(3*sizeof(float));
 m3x3[1] = (float *)malloc(3*sizeof(float));
 m3x3[2] = (float *)malloc(3*sizeof(float));

 autovetor[0] = (float *)malloc(3*sizeof(float));
 autovetor[1] = (float *)malloc(3*sizeof(float));
 autovetor[2] = (float *)malloc(3*sizeof(float));
 
 ma2 = (float **)malloc(npt * sizeof(float *)); /* aloca matriz ma2*/
 for(i=0; i<npt; i++)
    ma2[i] = (float *)malloc(3 * sizeof(float));

 for(i=0; i<npt; i++)
   for(j=0; j<3; j++)
     ma2[i][j] = mat[i][j];


 baricentro(ma2, baric, npt);
 mult_t(ma2, m3x3, npt);
 auto_jacob(m3x3, 3, autovalor, autovetor, &nrot);
 vet_sort(autovalor, autovetor, 3);


 
 var_para = autovalor[0]/(npt-1) + erro_pixel*erro_pixel;
 var_per = (autovalor[1] + autovalor[2])/(npt-1) + 2*erro_pixel*erro_pixel;

 val_reta = 2 * var_para / var_per;


 /* liberacao de memoria */

 free(m3x3[0]);
 free(m3x3[1]);
 free(m3x3[2]);
 
 free(autovetor[0]);
 free(autovetor[1]);
 free(autovetor[2]);
 
 for(i=0; i<npt; i++)
    free(ma2[i]);
 free(ma2);

  
  return(val_reta);
}

/* funcao para comparar a distancia com um valor max em mcrescimento e amad. */
float comp_dist(maxdist, comp_d0)
float maxdist,   /* dist. max permitida */
      comp_d0;   /* d0 = d0^2 */
{
  float d;
  
  d = 2.3 + maxdist/sqrt(comp_d0);
  d = d*d;
  
  return(d);
}

/* funcao para calculo da condicao do hiperboloide */
void cond_hiper(int j, int i, float **mpt, float *baric, float **autovetor,float *autovalor, float erro_pixel, float *condicao, float *dist, float *comp_d0)
{
    float x0, x1, x2, d0, d1, d2;

    x0= ((mpt[i][0] - baric[0])*autovetor[0][0] +
	 (mpt[i][1] - baric[1])*autovetor[1][0] +
	 (mpt[i][2] - baric[2])*autovetor[2][0]);
    d0= (autovalor[0]/(j-1) + erro_pixel * erro_pixel);
    x1= ((mpt[i][0] - baric[0])*autovetor[0][1] +
	 (mpt[i][1] - baric[1])*autovetor[1][1] +
	 (mpt[i][2] - baric[2])*autovetor[2][1]);
    d1= (autovalor[1]/(j-1) + erro_pixel * erro_pixel);
    x2= ((mpt[i][0] - baric[0])*autovetor[0][2] +
	 (mpt[i][1] - baric[1])*autovetor[1][2] +
	 (mpt[i][2] - baric[2])*autovetor[2][2]);
    d2= (autovalor[2]/(j-1) + erro_pixel * erro_pixel);

    *condicao = 1 + x0*x0/d0 - x1*x1/d1 - x2*x2/d2;
    *dist = (x0*x0+erro_pixel*erro_pixel)/d0 + (x1*x1+erro_pixel*erro_pixel)/d1 + (x2*x2+erro_pixel*erro_pixel)/d2;
    *comp_d0 = d0;
}

void crescimento(nptos, mpt, mat, ptr_cand_cres)
int nptos;   /* num de ptos no espaco  */
float **mpt, /* matriz (nptos x 3) dos ptos no espaco */
      **mat; /* matriz(nptos x 3) que sera passada para o calculo da
		variancia */
struct candidato *ptr_cand_cres; /* candidato para crescimento */
{
 int i, j, k, z, npt, nrot;
 float valor;
 struct reta_ptos *ptr_reta1, *ptr_reta2;

 float baric[3], autovalor[3], *autovetor[3], *m3x3[3], **ma2;
 float  dist, dist_melhor, condicao, comp_d0;

 int flag_condicao, ind_melhor;

 autovetor[0] = (float *)malloc(3*sizeof(float));
 autovetor[1] = (float *)malloc(3*sizeof(float));
 autovetor[2] = (float *)malloc(3*sizeof(float));
 
 m3x3[0] = (float *)malloc(3*sizeof(float));
 m3x3[1] = (float *)malloc(3*sizeof(float));
 m3x3[2] = (float *)malloc(3*sizeof(float)); 
 
 j = 0;
 npt = ptr_cand_cres->nptos;
 ptr_reta2 = ptr_cand_cres->ptr_reta;
 while(ptr_reta2)
   {
     mat[j] = mpt[ptr_reta2->indice_pto];
     j++;
     ptr_reta1 = ptr_reta2;
     ptr_reta2 = ptr_reta2->next;
   }

 z = j;


 

 /* --------------------------------------------------------------------
    impressao teste autovetores e autovalores dos candidatos a crescimento
    variaveis novas utilizadas  int ii, jj ---
{int ii,jj
 printf(" -- candidato para crescimento -- \n");
 
 ma2 = (float **)malloc(j * sizeof(float *));
 for(i=0; i<j; i++)
   ma2[i] = (float *)malloc(3 * sizeof(float));
      
 for(i=0; i<j; i++)
   for(k=0; k<3; k++)
	  ma2[i][k] = mat[i][k];
 
 baricentro(ma2, baric, j);
 mult_t(ma2, m3x3, j);
 auto_jacob(m3x3, 3, autovalor, autovetor, &nrot);
 vet_sort(autovalor, autovetor, 3);

 for(ii = 0; ii<3; ii++)
   {
       printf("autovalor[%d] = %f \n",ii,autovalor[ii]);
       printf("auto_vetor [%d] = ",ii);
       for(jj=0; jj<3; jj++)
	{
	    printf(" %f  ",autovetor[jj][ii]);
        }
       
       printf("\n\n");
    }
 
 for(i=0; i<j; i++)
   free(ma2[i]);
 free(ma2);

}
 ------------- FIM  DO TESTE  -----------------*/


 
 /* ---- fprintf(stderr,"cres: j = %d   npt = %d\n",j,npt);*/

 do
   {
      ma2 = (float **)malloc(j * sizeof(float *));
      for(i=0; i<j; i++)
	ma2[i] = (float *)malloc(3 * sizeof(float));
      
      for(i=0; i<j; i++)
	for(k=0; k<3; k++)
	  ma2[i][k] = mat[i][k];

      baricentro(ma2, baric, j);
      mult_t(ma2, m3x3, j);
      auto_jacob(m3x3, 3, autovalor, autovetor, &nrot);
      vet_sort(autovalor, autovetor, 3);
      
     flag_condicao = -1;
     ind_melhor = -1;
     for(i=0; i<nptos; i++)
       {
	   ptr_reta2 = ptr_cand_cres->ptr_reta;
	   while(ptr_reta2)  /* verifica se o pto i pertence a reta candidata */
	     {
		 if(ptr_reta2->indice_pto == i)
		   {
		       break;
		   }
	/*	 ptr_reta1 = ptr_reta2; */
		 ptr_reta2 = ptr_reta2->next;
	     }
	   if(ptr_reta2)
	     if(ptr_reta2->indice_pto == i)
	       continue;

	   if(ind_melhor == -1)
	     {
		 cond_hiper(j, i, mpt, baric, autovetor, autovalor, erro_pixel, &condicao, &dist_melhor, &comp_d0);

		 if(condicao < 0.0)
		   continue;
		 
		 if(dist_melhor>comp_dist(cres, comp_d0)) /*  CONDICAO 03-03-94 */
		   continue;
		 
		 ind_melhor = i;
		 
		 flag_condicao = 0;
	     }
	   else
	     {
		 cond_hiper(j, i, mpt, baric, autovetor, autovalor, erro_pixel, &condicao, &dist, &comp_d0);
		 
		 if(condicao < 0.0)
		   continue;
		 
		 if(dist>comp_dist(cres, comp_d0)) /*  CONDICAO 03-03-94 */
		   continue;
	   
		 if(dist < dist_melhor)
		   {
		       dist_melhor = dist;
		       ind_melhor = i;
		   }
	     }
       }

      
      if(flag_condicao ==0)  /* insere novo pto a lista */
	{
	    mat[j] = mpt[ind_melhor];
	    npt++;
	    valor = val_reta(mat, npt);
	    ptr_cand_cres->nptos = npt; /*incrementa nptos */
	    ptr_cand_cres->valor = valor;
	    ptr_reta1 = ins_reta_ptos(ptr_reta1, ptr_cand_cres);
	    ptr_reta1->indice_pto = ind_melhor;
	    j++;
	}
      
      for(i=0; i<z; i++)
	free(ma2[i]);
      free(ma2);

      z = j;

  }
   while(flag_condicao == 0);

 free(m3x3[0]);
 free(m3x3[1]);
 free(m3x3[2]);
 
 free(autovetor[0]);
 free(autovetor[1]);
 free(autovetor[2]);
/* ----
 ptr_reta1 = ptr_cand_cres->ptr_reta;

  j = 0;
 while(ptr_reta1)
   {
     ptr_reta1 = ptr_reta1->next;
     j++;
   }

   fprintf(stderr,"   cres: nptos = %d j= %d\n",ptr_cand_cres->nptos,j); 
-----*/   

}



/* melhor_cand - retorna um ponteiro para o melhor candidato
                 ( o que possui melhor qualidade) da lista de candidatos */
struct candidato *melhor_cand()
{
 struct candidato *ptr_cand, *ptr_cand_melhor;
 float valor, valor_max;
 unsigned char flag = 0;

 ptr_cand = ini_cand;

 if(ptr_cand == NULL)
   return(ptr_cand);

 if(ptr_cand->nptos == 2)
   return(ptr_cand);

 valor_max = ptr_cand->valor;
 ptr_cand_melhor = ptr_cand;
 ptr_cand = ptr_cand->next;


 while(ptr_cand)
   {
       if(ptr_cand->nptos == 2)
	 return(ptr_cand);
       
     valor = ptr_cand->valor;
     if(valor >= valor_max)
       {
	   valor_max = valor;
	   ptr_cand_melhor = ptr_cand;
       }
	            
     ptr_cand = ptr_cand->next;
   }
    

 return(ptr_cand_melhor);
}


struct candidato *amadurecimento(mpt, mat, nptos, ptos_nc)
float **mpt;  /* matriz (nptos x 3) dos ptos no espaco */     
float **mat;  /* matriz auxiliar utilizada no calculo de altovalores*/
int nptos;    /* num de ptos no espaco  */
unsigned char *ptos_nc; /* vetor cujo elemento indica se o pto foi
			   ou nao coberto */
{
 struct candidato *ptr_cand, *ptr_cand_melhor;
 struct reta_ptos *ptr_reta1, *ptr_reta2;
 int i, j, k, npt, ind_melhor, nrot;
 float baric[3], autovalor[3], *autovetor[3], *m3x3[3], **ma2;
 float  d, d_melhor, melhor_valor, condicao, comp_d0;

 ptr_cand_melhor = melhor_cand();
 if(ptr_cand_melhor==NULL)
   return(ptr_cand_melhor);
 
 ind_melhor = -1;

 autovetor[0] = (float *)malloc(3*sizeof(float));
 autovetor[1] = (float *)malloc(3*sizeof(float));
 autovetor[2] = (float *)malloc(3*sizeof(float));
 
 m3x3[0] = (float *)malloc(3*sizeof(float));
 m3x3[1] = (float *)malloc(3*sizeof(float));
 m3x3[2] = (float *)malloc(3*sizeof(float));

  /* --- impre teste  
 ptr_reta1 = ptr_cand_melhor->ptr_reta;
 printf("Melhor_cand : nptos = %d     valor = %.8f\n",ptr_cand_melhor->nptos,ptr_cand_melhor->valor);
 printf("     --indice = ");
 while(ptr_reta1)
   {
       printf("  %d",ptr_reta1->indice_pto);
       ptr_reta1 = ptr_reta1->next;
   }
 printf("\n");     ---- */
       

 j = 0;
 npt = ptr_cand_melhor->nptos;
 
 ptr_reta2 = ptr_cand_melhor->ptr_reta;
 while(ptr_reta2)
   {
     mat[j] = mpt[ptr_reta2->indice_pto];
     j++;
     ptr_reta1 = ptr_reta2;
     ptr_reta2 = ptr_reta2->next;
   }
 
 ma2 = (float **)malloc(j * sizeof(float *)); /* aloca matriz ma2*/
 for(i=0; i<j; i++)
    ma2[i] = (float *)malloc(3 * sizeof(float));

 for(i=0; i<j; i++)
   for(k=0; k<3; k++)
     ma2[i][k] = mat[i][k];

 baricentro(ma2, baric, j);
 mult_t(ma2, m3x3, j);
 auto_jacob(m3x3, 3, autovalor, autovetor, &nrot);
 vet_sort(autovalor, autovetor, 3);

 
 for(i=0; i<nptos; i++)
   {
     if( ptos_nc[i] == 1) /* pto nao coberto */
       {
	 ptr_reta2 = ptr_cand_melhor->ptr_reta;
	 while(ptr_reta2) /* verifica se o pto ja pertence ao candidato*/
	   {
	       if(ptr_reta2->indice_pto == i)
		 {
		     break;
		 }
	       ptr_reta2 = ptr_reta2->next;
	   }
	 if(ptr_reta2)
	   if(ptr_reta2->indice_pto == i)
	     continue;


	 if(ind_melhor == -1)
	   {
	       cond_hiper(j, i, mpt, baric, autovetor, autovalor, erro_pixel, &condicao, &d_melhor, &comp_d0);


	       if(d_melhor>comp_dist(amad, comp_d0)) 
		 continue;

	       ind_melhor = i;
	     }
	 else
	   {
	       cond_hiper(j, i, mpt, baric, autovetor, autovalor, erro_pixel, &condicao, &d, &comp_d0);
		   

	       if(d>comp_dist(amad, comp_d0))
		 continue;

	       if(d < d_melhor)
		 {
		     d_melhor = d;
		     ind_melhor = i;
		 }
	   }
       }
   }

  /* liberacao de memoria */

 free(m3x3[0]);
 free(m3x3[1]);
 free(m3x3[2]);
 
 free(autovetor[0]);
 free(autovetor[1]);
 free(autovetor[2]);
 
 for(i=0; i<j; i++)
    free(ma2[i]);
 free(ma2);

 if(ind_melhor==-1)
   {
/* alteracao para versao com condicao em amadurecimento 24-02-94 */
       if(ptr_cand_melhor != NULL)
	 {
	     del_candidato(ptr_cand_melhor);
	     ptr_cand_melhor = melhor_cand();
	 }
/* fim da alteracao     */
       return(ptr_cand_melhor);
   }

/* insere novo pto  a lista de candidatos */       
 mat[j] = mpt[ind_melhor];
 npt++;
 melhor_valor = val_reta(mat, npt);
 ptr_cand_melhor->nptos = npt;
 ptr_cand_melhor->valor = melhor_valor;
 ptr_reta1 = ins_reta_ptos(ptr_reta1, ptr_cand_melhor);
 ptr_reta1->indice_pto = ind_melhor;

 return(ptr_cand_melhor);
}

void elimina(ptr_cand_cres, ptos_nc, nptos_nc, mat, mpt, nptos)
struct candidato *ptr_cand_cres; /* candidato retornado do crescimento */
unsigned char *ptos_nc; /* vetor com os ptos nao cobertos.
			 se o elemento do vetor = 1 => pto com tal
			 indice nao foi coberto. Se for = 0 em caso
			 contrario */
int *nptos_nc;  /* num de pontos nao cobertos */
float **mat;  /* matriz auxiliar utilizada no calculo de altovalores*/
float **mpt;  /* matriz (nptos x 3) dos ptos no espaco */
int nptos; /* num de ptos no espaco */
{
 struct candidato *ptr_cand1, *ptr_cand2;
 struct reta_ptos *ptr_reta_cres, *ptr_reta1, *ptr_reta2, *ptr_reta_aux;
 struct reta_adulta *ptr_reta_adulta;

 float b[3], autovalor[3], *autovetor[3], *m3x3[3], **ma2, var_per, var_para;
 float x_ini_iso, y_ini_iso, z_ini_iso, /* pto inicial e final da reta */
       x_fim_iso, y_fim_iso, z_fim_iso;

 
 int indice, j, i, k, imax, imin, nptos_original, nrot, npt;

 int ii, jj;

 float d, dmax, dmin;

 autovetor[0] = (float *)malloc(3*sizeof(float));
 autovetor[1] = (float *)malloc(3*sizeof(float));
 autovetor[2] = (float *)malloc(3*sizeof(float));

 m3x3[0] = (float *)malloc(3*sizeof(float));
 m3x3[1] = (float *)malloc(3*sizeof(float));
 m3x3[2] = (float *)malloc(3*sizeof(float));

 
 ptr_reta_cres = ptr_cand_cres->ptr_reta;

  j = 0;
 while(ptr_reta_cres)
   {
     ptr_reta_cres = ptr_reta_cres->next;
     j++;
   }

  ptr_reta_cres = ptr_cand_cres->ptr_reta;

/*  fprintf(stderr,"   elim: nptos = %d  j = %d\n",ptr_cand_cres->nptos,j);*/

 while(ptr_reta_cres)
   {
     ptr_cand2 = ini_cand;
     indice = ptr_reta_cres->indice_pto;
     ptos_nc[indice] = 0; /* pto foi coberto */


     while(ptr_cand2)
       {
	 if(ptr_cand2 == ptr_cand_cres) /* verifica se e a mesma reta */
	   {
	     ptr_cand2 = ptr_cand2->next;
	     continue;
	   }

	 ptr_reta2 = ptr_cand2->ptr_reta;
	
	 nptos_original = ptr_cand2->nptos;
	 while(ptr_reta2)
	   {
	     if(ptr_reta2->indice_pto == indice)/* retira pto da lista de candidatos(reta_ptos) */
	       {
		   ptr_reta1 = ptr_reta2->next;
		   del_reta_ptos(ptr_reta2, ptr_cand2);
		   (ptr_cand2->nptos)--;
		   ptr_reta2 = ptr_reta1;
	       }
	     else
	       {
		 ptr_reta2 = ptr_reta2->next;
	       }
	   }

	 if(ptr_cand2->nptos <= 1)/* retira cand2 da lista */
	   {
	       ptr_cand1 = ptr_cand2->next;
	       del_candidato(ptr_cand2);
	       ptr_cand2 = ptr_cand1;
	   }
	 else
	   {
	     if(nptos_original != ptr_cand2->nptos) /* se ok recalcula */
	       {                                    /* val_reta */
		 ptr_reta_aux = ptr_cand2->ptr_reta;
		 j = 0;
		 while(ptr_reta_aux)
		   {
		     mat[j] = mpt[ptr_reta_aux->indice_pto];
		     ptr_reta_aux = ptr_reta_aux->next;
		     j++;
		   }
		 if(ptr_cand2->nptos == 2)
		   ptr_cand2->valor = dist(mat[0],mat[1]);
		 else
		   ptr_cand2->valor = val_reta(mat, j);
	       }
	     ptr_cand1 = ptr_cand2;  /* ?????? pra que */
	     ptr_cand2 = ptr_cand2->next;
	   }
       }
     ptr_reta_cres = ptr_reta_cres->next;
   }


 ptr_reta_cres = ptr_cand_cres->ptr_reta;
 j = 0;
 while(ptr_reta_cres)
   {
     mat[j] = mpt[ptr_reta_cres->indice_pto];
     ptr_reta_cres = ptr_reta_cres->next;
     j++;
   }
 npt = ptr_cand_cres->nptos;

 ma2 = (float **)malloc(j * sizeof(float *)); /* aloca matriz ma2*/
 for(i=0; i<j; i++)
    ma2[i] = (float *)malloc(3 * sizeof(float));

 for(i=0; i<j; i++)
   for(k=0; k<3; k++)
     ma2[i][k] = mat[i][k];

 baricentro(ma2, b, j);
 mult_t(ma2, m3x3, j);
 auto_jacob(m3x3, 3, autovalor, autovetor, &nrot);
 vet_sort(autovalor, autovetor, 3);


 /* j =num de ptos da reta */

 /* --------------------------------------------------------------------
    impressao teste autovetores e autovalores das retas adultas
    variaveis novas utilizadas  int ii, jj
*/
 

/*  
 for(ii = 0; ii<3; ii++)
   {
       printf("autovalor[%d] = %f \n",ii,autovalor[ii]);
       printf("auto_vetor [%d] = ",ii);
       for(jj=0; jj<3; jj++)
	{
	    printf(" %f  ",autovetor[jj][ii]);
        }
       
       printf("\n\n");
    }
*/ 
 /*------------- FIM DO TESTE  -----------------*/



 var_para = autovalor[0]/(npt-2);
 var_per = var_perp(ma2, var_para, npt);

 dmax = (ma2[0][0]*autovetor[0][0] +
	 ma2[0][1]*autovetor[1][0] +
	 ma2[0][2]*autovetor[2][0]);

 dmin = (ma2[0][0]*autovetor[0][0] +
	 ma2[0][1]*autovetor[1][0] +
	 ma2[0][2]*autovetor[2][0]);
 imax = 0;
 imin = 0;
 for(i=1; i<j; i++)
   {
     d = (ma2[i][0]*autovetor[0][0] +
	  ma2[i][1]*autovetor[1][0] +
	  ma2[i][2]*autovetor[2][0]);

     if(d > dmax)
       {
	 dmax = d;
	 imax = i;
       }
     if(d < dmin)
       {
	 dmin = d;
	 imin = i;
       }
   
   }

 x_ini_iso = b[0] + dmin*autovetor[0][0];
 x_fim_iso = b[0] + dmax*autovetor[0][0];
 y_ini_iso = b[1] + dmin*autovetor[1][0];
 y_fim_iso = b[1] + dmax*autovetor[1][0];
 z_ini_iso = b[2] + dmin*autovetor[2][0];
 z_fim_iso = b[2] + dmax*autovetor[2][0];
 
 {
   int delta_y;
   float condicao;

   /* calculo da condicao da projecao x num de ptos da reta */
/* ---   delta_y = abs(yp2 - yp1);
         condicao = (float)(j-n_reta/2.0)/delta_y;
 -----*/
 

/* --   if(condicao >= 0.5)
     {
       fprintf(seg_reais_2d,"%5d %5d   ",xp1,yp1);
       fprintf(seg_reais_2d,"%5d %5d  %5d  %5d  %8.4f\n",xp2,yp2,j,delta_y,condicao);
       
       fprintf(seg_reais_3d,"%f %f %f\n%f %f %f\n",
	       x_ini_3d,y_ini_3d,z_ini_3d,x_fim_3d,y_fim_3d,z_fim_3d);
       
       fprintf(seg_iso,"%f %f %f\n%f %f %f\n",
	       x_ini_iso,y_ini_iso,z_ini_iso,x_fim_iso,y_fim_iso,z_fim_iso);
	       
--- */  
   if(npt>n_reta)
     {
       num_total_ptos += j;
       num_total_retas++;
    
       ins_reta_adulta();
       ptr_reta_adulta = fim_reta_adulta;

       ptr_reta_adulta->x_ini_iso = x_ini_iso;
       ptr_reta_adulta->y_ini_iso = y_ini_iso;
       ptr_reta_adulta->z_ini_iso = z_ini_iso;
       ptr_reta_adulta->x_fim_iso = x_fim_iso;
       ptr_reta_adulta->y_fim_iso = y_fim_iso;
       ptr_reta_adulta->z_fim_iso = z_fim_iso;
       ptr_reta_adulta->qualidade = ptr_cand_cres->valor;
       ptr_reta_adulta->nptos = npt;
     }
  /* } */ 
       

/* --   fprintf(stdout," num. pontos = %d  delta_y = %d  condicao = %f\n",j,delta_y,condicao);
 --*/
 }  
 

 *nptos_nc = 0;
 for(i=0; i<nptos; i++)
   if(ptos_nc[i] == 1)
     (*nptos_nc)++;


 del_candidato(ptr_cand_cres); /* elimina candidato ja adulto */
 
 
 /* liberacao de memoria */

 free(m3x3[0]);
 free(m3x3[1]);
 free(m3x3[2]);
 
 free(autovetor[0]);
 free(autovetor[1]);
 free(autovetor[2]);

 for(i=0; i<j; i++)
    free(ma2[i]);
 free(ma2);
 

}

/* -- escreve saida nos arquivos em ordem decrescente de qualidade */
void escreve_saida()
{
  int i;
  struct reta_adulta *ptr;
  float qualidade;
  struct reta_adulta **vetor_ptr;
  int *vet_indice;
  float *value;
  float x_ini_3d, x_fim_3d, y_ini_3d, y_fim_3d, z_ini_3d, z_fim_3d;
  int xp1, xp2, yp1, yp2; /* coordenadas projetadas */
  float x_ini_iso, y_ini_iso, z_ini_iso, /* pto inicial e final da reta */
        x_fim_iso, y_fim_iso, z_fim_iso;
  
  for(i=0; i<num_total_retas; i++)
    {
      vet_indice = (int*)malloc(num_total_retas * sizeof(int));
      value = (float*)malloc(num_total_retas * sizeof(float));
      vetor_ptr = (struct reta_adulta**)malloc(num_total_retas * sizeof(struct reta_adulta*));
    }
  
  i = 0;
  ptr = ini_reta_adulta;
  while(ptr)
    {
      vetor_ptr[i] = ptr;
      vet_indice[i] = i;
      value[i] = (float)ptr->nptos;
      i++;
      ptr = ptr->next;
    }
    
  sort(num_total_retas, value, vet_indice); /* ordena em ordem crescente de 
                                        qualidade */

  for(i=(num_total_retas-1); i>=0; i--)
    {
      x_ini_iso = vetor_ptr[vet_indice[i]]->x_ini_iso;
      y_ini_iso = vetor_ptr[vet_indice[i]]->y_ini_iso;
      z_ini_iso = vetor_ptr[vet_indice[i]]->z_ini_iso;
      x_fim_iso = vetor_ptr[vet_indice[i]]->x_fim_iso;
      y_fim_iso = vetor_ptr[vet_indice[i]]->y_fim_iso;
      z_fim_iso = vetor_ptr[vet_indice[i]]->z_fim_iso;
      
    
    
         /* ------- DESNORMALIZACAO DAS COORDENADAS X Y Z
                conversao de iso para 3d -------*/

      conv_iso_3d(x_ini_iso, y_ini_iso, z_ini_iso, &x_ini_3d, &y_ini_3d, &z_ini_3d);
      conv_iso_3d(x_fim_iso, y_fim_iso, z_fim_iso, &x_fim_3d, &y_fim_3d, &z_fim_3d);

   /* --------- PROJECAO NO PLANO -------------- */
      xp1=(int) (foco * x_ini_3d/z_ini_3d + const_cord_x);
      yp1=(int) (foco * y_ini_3d/z_ini_3d + const_cord_y);
      
      xp2=(int) (foco * x_fim_3d/z_fim_3d + const_cord_x);
      yp2=(int) (foco * y_fim_3d/z_fim_3d + const_cord_y);

   /* -----------ESCRITA EM ARQUIVO ---------- */

      fprintf(seg_reais_2d,"%5d %5d   ",xp1,yp1);
      fprintf(seg_reais_2d,"%5d %5d  %5d  %10.4f\n",xp2,yp2,vetor_ptr[vet_indice[i]]->nptos,vetor_ptr[vet_indice[i]]->qualidade);
      
      fprintf(seg_reais_3d,"%f %f %f\n%f %f %f\n",
	      x_ini_3d,y_ini_3d,z_ini_3d,x_fim_3d,y_fim_3d,z_fim_3d);
       
      fprintf(seg_iso,"%f %f %f\n%f %f %f\n",
	      x_ini_iso,y_ini_iso,z_ini_iso,x_fim_iso,y_fim_iso,z_fim_iso);
      

      
    }
  
}



segment()
{

 float **mpt; /* matriz de ptos */
 float **mat; /* matriz auxiliar utilizada no calculo de altovalores*/
 unsigned char *ptos_nc; /* vetor com os ptos nao cobertos.
			 se o elemento do vetor = 1 => pto com tal
			 indice nao foi coberto. Se for = 0 em caso
			 contrario */
 int nptos,     /* num de ptos no espaco */
     nptos_nc;  /* num de ptos nao cobertos */
 struct candidato *ptr_cand_cres; /* candidato para crescimento */
 struct reta_ptos *ptr_aux;
  
 int i, t;

 int xp, yp;

 FILE *entrada;
 
/*--   FILE *arq_cand;
     arq_cand = fopen("arq_cand","w");
--*/     
     
 entrada = fopen(entrada_iso_casa,"r");


 fscanf(entrada,"%d\n",&nptos);

 fprintf(stdout," Nptos para segmentacao = %d \n",nptos); 

 mpt = (float **)malloc(nptos * sizeof(float *));
 for(i=0; i<nptos; i++)
    mpt[i] = (float *)malloc(3 * sizeof(float));

 for(i=0; i<nptos; i++)
   fscanf(entrada,"%f %f %f\n",&mpt[i][0],&mpt[i][1],&mpt[i][2]);


 fclose(entrada);
/*----    ver(mpt, nptos);  ---*/

 
 mat = (float **)malloc(nptos * sizeof(float *)); /* aloca matriz mat*/
 for(i=0; i<nptos; i++)
    mat[i] = (float *)malloc(3 * sizeof(float));

 ptos_nc = (unsigned char *)malloc(nptos * sizeof(unsigned char));
 nptos_nc = nptos;
 for(i=0; i<nptos; i++)
    ptos_nc[i] = 1;  /* todos ptos nao foram cobertos */


 start = now();
 gera_cand(mpt, nptos); /* gera candidatos iniciais(pares+proximos) */
 stop = now();
 t1 = stop -start;
 fprintf(stdout," PARES - Total time (ms) = %.0f\n",t1/1000.0);
 
 while(nptos_nc > 0)
   {
       start = now();
       do
       {
	 ptr_cand_cres = amadurecimento(mpt, mat, nptos, ptos_nc);
	 if(ptr_cand_cres == NULL)
	   break;
       }
       while(ptr_cand_cres->nptos < n_reta);
       if(ptr_cand_cres == NULL)
	 break;

       stop = now();
       t2+= stop - start;

/* ----ESCRITA TESTE DOS PONTOS CANDIDATOS EM ARQUIVOS ----
     ptr_aux = ptr_cand_cres->ptr_reta;
 
     while(ptr_aux)
	   {
	       xp = (int)(foco * mpt[ptr_aux->indice_pto][0]/mpt[ptr_aux->indice_pto][2]);
	       yp = (int)(foco * mpt[ptr_aux->indice_pto][1]/mpt[ptr_aux->indice_pto][2]);
	       fprintf(arq_cand,"%d %d\n",xp,yp);
	       ptr_aux = ptr_aux->next;
	   }
       fprintf(arq_cand,"%d %d\n",-1,-1);

     ----------- FIM DA ESCRITA TESTE ------- */       

       
       start = now(); 
       crescimento(nptos, mpt, mat, ptr_cand_cres);
       stop = now();
       t3+= stop -start;

       
       start = now(); 
       elimina(ptr_cand_cres, ptos_nc, &nptos_nc, mat, mpt, nptos);
       stop = now();
       t4+= stop -start;

   }
   
 escreve_saida();

 fprintf(stdout," ESCOLHE CAND - Total time (ms) =  %.0f\n",t2/1000.0);
 fprintf(stdout," CRESC - Total time (ms) =  %.0f\n",t3/1000.0);
 fprintf(stdout," ELIMI - Total time (ms) =  %.0f\n",t4/1000.0);
 fprintf(stdout," Total de pontos em retas =  %d\n",num_total_ptos);
 fprintf(stdout," Total de retas =  %d\n",num_total_retas);
}

void main(argc,argv)
int argc;
char *argv[];
{
  char parametros[50], saida[50], saida_seg_reais_3d[50],
       saida_seg_reais_2d[50],saida_seg_iso[50];
  char aux[100];
  
  FILE *arq_parametros;
  
  strcpy(parametros, argv[2]);
  strcat(parametros, ".parms");
  
  /* ENTRADA DE DADOS  */
  if((arq_parametros = fopen(parametros, "r")) == NULL)
    {
      fprintf(stderr,"\n ---- Arquivo de parametros nao pode ser aberto -EXIT\n");
      exit(1);
    } 

  fgets(aux, 98, arq_parametros);  /* leitura do cabecalho   */
  fscanf(arq_parametros,"erro_pixel = %f\n",&erro_pixel);
  fscanf(arq_parametros,"n_reta = %d\n",&n_reta);
  fscanf(arq_parametros,"foco = %f\n",&foco);
  fscanf(arq_parametros,"baseline = %f\n",&baseline);
  
  
  /* preparacao dos nomes dos arquivos de saidas */
  strcpy(saida, argv[1]);
  strcat(saida, "-");
  strcat(saida, argv[2]); 
  
  strcpy(saida_seg_reais_3d, saida);
  strcpy(saida_seg_reais_2d, saida);
  strcpy(saida_seg_iso, saida);
  
  strcat(saida_seg_reais_3d, "_3d.segs");
  strcat(saida_seg_reais_2d, "_2d.segs");
  strcat(saida_seg_iso, "_iso.segs");
  
  /* preparacao do nome de arquivo para entrada de ptos iso para segmentar */
  strcpy(entrada_iso_casa, saida);
  strcat(entrada_iso_casa, "_iso.casa");
  
  /* abertura de arquivos para saida de segmentos */
  seg_reais_2d = fopen(saida_seg_reais_2d,"w");
  seg_iso = fopen(saida_seg_iso,"w");
  seg_reais_3d = fopen(saida_seg_reais_3d,"w");
  
  /* imprimir parametros lidos do stdout */
  fprintf(stdout,"     TESTE  cod. ( %s )\n",saida);
  
  fprintf(stdout,"erro_pixel = %f\n",erro_pixel);
  fprintf(stdout,"n_reta = %d\n",n_reta);
  
  const_cord_x = (SIZEX-1.0)/2.0;
  const_cord_y = (SIZEY-1.0)/2.0;

/* ---
  fprintf(stderr,"\n\n amad (~4)= ");
  scanf("%f",&amad);
  fprintf(stderr,"\n\n cres (~16)= ");
  scanf("%f",&cres);
  fprintf(stderr,"\n\n gera (~12)= ");
  scanf("%f",&gera);

---*/

  segment();
}