//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
#include <main.h>
#include <ajst.h>
#include <cmpi.h>
#include <matrix.h> 
#include <float_image_from_uint16_image.h>
#include <float_image_to_uint16_image.h>

/*******************************************************************************************************/
/*******************************************************************************************************/
/*******************************************************************************************************/
int main(int argc, char** argv)
{
  int aux;

  //le o nome da imagem e carrega a imagem para memoria
  char name_image_in[30];
  strcpy(name_image_in,argv[1]);
  image *img = ex_read_image(NULL, name_image_in);
  int NX = img->sz[X];
  int NY = img->sz[Y];

  //nome do modelo usado
  model *mod = get_model(atoi(argv[2]));  

  //decidir intervalo de variação dos parâmetros do modelo
  interval_t range_init[MAX_PARAMS];
  choose_initial_param_ranges(model, NX, NY, range_init);

  //cria a imagem em multi-escala e bordas
  image_mult_scale mult_scale;
  create_image_mult_scale(&mult_scale,name_image_in);

  //escala máxima da pirâmide:
  int max_scale = mult_scale.num_scales - 1;

  //comeca numa escala em que o modelo tem ~1 pixel de tamanho: 
  double max_size = get_max_model_size(mod, range_init);
  int scale = (int)ceil(fmax(log2(max_size)-0.5, 0.0)); 
  assert(scale >= 0);
  demand(scale <= max_scale, "model is too large for image");

  time_t inicio, fim;             
  time(&inicio);
  //cria uma lista inicial de candidatos
  set_of_candidates c;
  create_initial_set_of_candidates(&c, scale, mod, range_init);   

  //gera as imagens dos candidatos e calcula a qualidade  
  printf("\n Lista Inicial de Candidatos Gerada....");            

  //exit(1);
  //enquanto nao chegar na escala original
  while (1)
  {       
    printf("\nScale [%d]", scale);
    print_candidates(&c, scale);
    evaluate_candidates(&c, mult_scale.edges[scale], scale);
    sort_candidates(&c);
    if (scale <= 0) { break; }
    if (show_cands) { show_candidates(&c, mult_scale.edges[scale], scale); }
    scale--;
    update_candidates(&c, scale, mult_scale.edges[scale]);
  }
  time(&fim);
  printf("end of main loop\n "); 

  printf("occurrences found\n", difftime(fim,inicio));
  show_candidates(&c, mult_scale.edges[scale], scale);
  printf("total running time: %lf sec\n", difftime(fim,inicio));

  printf("\n **********************************************************************");
  return 0; 
}

void update_candidates(&c, scale, mult_scale.edges[scale])
{
  start new candidate list newc;
  for each candidate ck in c
    {
      double step[MAX_PARAMS];
      compute_steps(ck, scale, step);  //compute parameter steps that cause change of {~2^scale}
      split_candidate(ck, steps, new_c);
    }

}

/*************************************************************************/
float_image_t *ex_read_image(FILE *rd, char *name)
  { bool_t close_it = FALSE;
    if (rd == NULL) { rd = open_read(name, FALSE); close_it = TRUE; }
    uint16_image_t *pim = uint16_image_read_pnm_file(rd);
    float_image_t *fim = float_image_from_uint16_image(pim, NULL, NULL, FALSE);
    uint16_image_free(pim);
    if (close_it) { fclose(rd); }
    return fim;
  }

void ex_write_image(FILE *wr, char *name, float_image_t *img)
  { bool_t close_it = FALSE;
    if (wr == NULL) { wr = open_write(name, FALSE); close_it = TRUE; }
    int chns = img->sz[0];
    uint16_image_t *pim = float_image_to_uint16_image(img, chns, NULL, NULL, NULL, 255, FALSE);
    bool_t forceplain = FALSE;
    bool_t verbose = FALSE;
    uint16_image_write_pnm_file(wr, pim, forceplain, verbose);
    if (close_it) { fclose(wr); }
    uint16_image_free(pim);
  }

// Last edited on 2017-06-30 01:14:57 by stolfilocal