/* programa que reune pontos distantes de uma constante entre si
   em um unico ponto denominado vertice.
   Os pontos serao lidos de um arquivo no formato
   x y z da entrada definida pelo usuario */

#include <stdio.h>
#include <math.h>
#define NIL -1
#define SIZEX 512.0
#define SIZEY 512.0

FILE *entrada, *saida;
float erro_pixel, foco;



/* 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);
}


verifica()  /* verifica os ptos distantes de um certo valor e os
	       transforma em extremos de arestas de um grafo */
{
 float **mpt;  /* matriz de pontos no espaco */
 int *mat;  /* vetor utilizado no processamento do grafo */
 int nptos;   /* num. de ptos no espaco */

 char s[255];
 int i, j, x, y, vertx_2d, verty_2d;
 float d, raio_max, vertx, verty, vertz, k, const_cord_x, const_cord_y;
 int kte;
/* raio_max = 7 * erro_pixel;*/
/* raio_max = 2*erro_pixel; */
 printf("kte = ");
 scanf("%d",&kte);
 raio_max = kte*erro_pixel;
 
 const_cord_x = (SIZEX-1.0)/2.0;
 const_cord_y = (SIZEY-1.0)/2.0;
 
 
 nptos = 0;
  
 while((fgets(s, 254, entrada)) != NULL)
   nptos++;

 
 fprintf(stderr,"nptos = %d",nptos);

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

 mat = (int *)malloc(nptos * sizeof(int));
 
 
 rewind(entrada);

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

 
 for(i=0; i<nptos; i++)
   mat[i] = NIL;

 for(i=0; i<nptos; i++)
   for(j=i; j<nptos; j++)
     {
	 d = dist(mpt[i], mpt[j]);

	 if(d<raio_max)
	   {
	       x = i;
	       y = j;
	   	 
	       while(mat[x] != NIL)
		 x = mat[x];
	       
	       while(mat[y] != NIL)
		 y = mat[y];
	       
	       if(x != y)
		 mat[x] = y;
	   }
     }
 

   /* Impressao  */
    for(i=0; i<nptos; i++)
      {
	  k = 0.0;
	  vertx = 0.0;
	  verty = 0.0;
	  vertz = 0.0;
	  if( mat[i] == NIL)
	    {
		fprintf(stderr,"\nNova componente\n   ");
		for(j=0; j<nptos; j++)
		  {
		      x = j;
		      while(mat[x] != NIL)
			x = mat[x];
		      if(x == i)
			{
			    k = k + 1.0;
			    vertx += mpt[j][0];
			    verty += mpt[j][1];
			    vertz += mpt[j][2];
			    fprintf(stderr," %d ",j);
			}
		  }
		vertx /= k;
		verty /= k;
		vertz /= k;
		fprintf(saida,"%f %f %f\n",vertx,verty,vertz);

	/*	vertx_2d = foco*vertx/vertz + const_cord_x;
		verty_2d = foco*verty/vertz + const_cord_y;
		printf("%d %d\n",vertx_2d,verty_2d); EM 2-d */
	    }
      }


  


}


void main(argc, argv)
int argc;
char *argv[];
{

  char parametros[50], saida_aux[50],saida_log[50], saida_vert[50], aux[100];
  char  entrada_iso_segs[50];

  double start, stop; /* para medida de tempo de execucao */
  FILE *arq_parametros;

  strcpy(parametros, argv[2]);
  strcat(parametros, ".parms");
  
  strcpy(saida_aux, argv[1]);
  strcat(saida_aux, "-");
  strcat(saida_aux, argv[2]);

  strcpy(entrada_iso_segs, saida_aux);
  strcat(entrada_iso_segs, "_iso.segs");  
  
  strcpy(saida_vert, saida_aux);
  strcat(saida_vert, "_iso.vert");
  
  saida = fopen(saida_vert, "w");
  entrada = fopen(entrada_iso_segs, "r");
  
  arq_parametros = fopen(parametros, "r");
/*  file_log = fopen(saida_log, "w");*/
  
  fgets(aux, 98, arq_parametros);  /* leitura do cabecalho   */
  fscanf(arq_parametros,"erro_pixel = %f\n",&erro_pixel);
  fgets(aux, 98, arq_parametros);  /* leitura da linha n_reta =*/
  fscanf(arq_parametros,"foco = %f\n",&foco); 
  fprintf(stderr,"\n\n     Uniao em vertices.\n");

  fprintf(stderr,"\n\n       Dados.\n");
  fprintf(stderr,"\n Arquivo de vertices de entrada = %s",entrada_iso_segs);
  fprintf(stderr,"\n Arquivo saida dos vertices unidos = %s",saida_vert);
  fprintf(stderr,"\n erro posicional erro_pixel = %f",erro_pixel);
  
  verifica();
}