DOCS/paper_snake_gpu/SNAKE_NO_SSE/snake2D.c.gcov

   1         -:    0:Source:/home/perrot/SNAKE_2D3D/src/snake2D.c
   2         -:    0:Graph:snake2D.gcno
   3         -:    0:Data:snake2D.gcda
   4         -:    0:Runs:1
   5         -:    0:Programs:1
   6         -:    1:/**
   7         -:    2: * \file snake2D.c
   8         -:    3: * \brief snake polygonale approche region sous hypothese Gaussienne ou Gamma.
   9         -:    4: * \author NB - PhyTI
  10         -:    5: * \version x.x
  11         -:    6: * \date 20 decembre 2009
  12         -:    7: *
  13         -:    8: * traitement d'images en entiers 16 bits non signe : ppm
  14         -:    9: * USAGE : SNAKE2D image.pgm 0 (ou 1)
  15         -:   10: */
  16         -:   11:
  17         -:   12:#include <stdio.h>
  18         -:   13:
  19         -:   14:#include "constantes.h"
  20         -:   15:#include "structures.h"
  21         -:   16:#include "lib_alloc.h"
  22         -:   17:#include "lib_images.h"
  23         -:   18:#include "lib_math.h"
  24         -:   19:#include "lib_snake_cumul.h"
  25         -:   20:#include "lib_snake_common.h"
  26         -:   21:
  27         -:   22:/* debug */
  28         -:   23:#include "lib_snake_codage_gl.h"
  29         -:   24:#include "lib_snake_move.h"
  30         -:   25:
  31         -:   26:
  32         -:   27:
  33         -:   28:int main(int argc, char **argv)
  34         1:   29:{
  35         -:   30:  /* declaration des variables */
  36         -:   31:  int ret ;
  37         -:   32:  int Prof ;        /* profondeur en octets */
  38         -:   33:  int I_dim ;       /* hauteur de l'image */
  39         -:   34:  int J_dim ;       /* largeur de l'image */
  40         -:   35:  int N_dim ;       /* I_dim*J_dim */
  41         -:   36:  int Nb_level ;    /* dynamique de l'image */
  42         -:   37:  char *File_name ;
  43         -:   38:  char *PDF ;
  44         -:   39:
  45         -:   40:  /* images */
  46         -:   41:  int **Image_in, **Image_tmp ;
  47         -:   42:  union pixel_cumul_sse ** Images_cumul ;
  48         -:   43:
  49         -:   44:  /* snake : definition */
  50         -:   45:  struct snake_node* Snake ; /* premier noeud du snake */
  51         -:   46:  int Nb_noeud ;             /* Nombre de noeuds de snake */
  52         -:   47:  /* snake : statistique pour la vraisemblance */
  53         1:   48:  int Stat_sum_1 = 0 ;       /* Nb pixels a l'interieur du snake */
  54         1:   49:  int64 Stat_sum_x = 0 ;     /* Somme des xn a l'interieur du snake */
  55         1:   50:  int64 Stat_sum_x2 = 0 ;    /* Somme des xn^2 a l'interieur du snake */
  56         1:   51:  int64 SUM_X = 0 ;          /* Somme des xn sur l'image */
  57         1:   52:  int64 SUM_X2 = 0 ;         /* Somme des xn^2 sur l'image */
  58         -:   53:  /* snake : statistiques pour la longueur de codage du modele */
  59         -:   54:  //int Stat_sum_lsegment = 0 ; /* Somme des longueurs des segments */
  60         -:   55:  //int Stat_sum_lsegment2 = 0 ; /* Somme des carres des longueurs des segments*/
  61         -:   56:
  62         -:   57:  /* pointeur vers la fonction de calcul de longueur des niveaux de gris (log-vraisemblance) */
  63         -:   58:  double(*FCN_codage_gl)(int,int64,int64,int,int64,int64) ;
  64         -:   59:
  65         -:   60:  /* variables de calculs */
  66         -:   61:  int *Liste_pixel_segment ;
  67         -:   62:  struct timeval chrono, chrono_all ;
  68         -:   63:
  69         -:   64:  /* lecture argument entree (basique!) */
  70         1:   65:  File_name = argv[1] ;
  71         -:   66:
  72         -:   67:  /* verif type image (pgm 8/16) */
  73         1:   68:  ret = type_image_ppm(&Prof, &I_dim, &J_dim, &Nb_level, File_name) ;
  74         -:   69:
  75         1:   70:  if ((ret == 0) | (Prof == 3))
  76         -:   71:    {
  77     #####:   72:      printf("format non pris en charge ... exit\n") ;
  78     #####:   73:      return(0) ;
  79         -:   74:    }
  80         1:   75:  N_dim = I_dim*J_dim ;  /* nombre de pixels de l'image */
  81         -:   76:
  82         -:   77:  /* infos */
  83         1:   78:  printf("Image : %s\n", File_name) ;
  84         1:   79:  printf("lecture OK : %d\n", ret) ;
  85         1:   80:  printf("Image (%d x %d) pixels\n", I_dim, J_dim) ;
  86         1:   81:  printf("Dynamique : %d\n", Nb_level) ;
  87         -:   82:
  88         -:   83:  /* Allocation */
  89         1:   84:  Image_in = new_matrix_int(I_dim, J_dim) ;
  90         1:   85:  Image_tmp = new_matrix_int(I_dim, J_dim) ;
  91         1:   86:  Images_cumul = new_matrix_pixel_cumul_sse(I_dim, J_dim) ;
  92         1:   87:  Liste_pixel_segment = malloc(sizeof(int)*2*(I_dim+J_dim)) ;
  93         -:   88:
  94         -:   89:  /* chargement image d'entree */
  95         1:   90:  load_pgm2int(Image_in, I_dim, J_dim, Nb_level, File_name) ;
  96         -:   91:
  97         -:   92:  /* calcul des images cumulees */
  98         1:   93:  tic(&chrono, NULL) ;
  99         1:   94:  calcul_images_cumulees(Image_in, Images_cumul, I_dim, J_dim, &SUM_X, &SUM_X2) ;
 100         1:   95:  toc(chrono, "temps calcul images cumulees") ;
 101         -:   96:
 102         -:   97:  /* creation du snake initiale 4 noeuds */
 103         -:   98:  //Snake = genere_snake_rectangle(&Nb_noeud, 50, 50, 200, 200, I_dim, J_dim) ;
 104         -:   99:  //Snake = genere_snake_rectangle(&Nb_noeud, 200, 400, 300, 500, I_dim, J_dim) ;
 105         1:  100:  Snake = genere_snake_rectangle_bords(&Nb_noeud, 50, I_dim, J_dim) ;
 106         -:  101:
 107         1:  102:  tic(&chrono, NULL) ;
 108         -:  103:
 109         -:  104:  /* Initialise les contributions des segments du snake*/
 110         1:  105:  init_contrib_snake(Snake, Images_cumul, Liste_pixel_segment) ;
 111         -:  106:
 112         -:  107:  /* calcul les statistiques du snake */
 113         1:  108:  calcul_stat_snake(Snake, Images_cumul, Liste_pixel_segment,
 114         -:  109:                    &Stat_sum_1, &Stat_sum_x, &Stat_sum_x2) ;
 115         -:  110:
 116         1:  111:  toc(chrono, "temps init + calcul stats") ;
 117         -:  112:
 118         -:  113:
 119         -:  114:  /* debug : affichage snake */
 120         1:  115:  int Verbose = 1 ;
 121         1:  116:  int VERBOSE = 1 ;
 122         1:  117:  int Display = 1 ;
 123         1:  118:  int DISPLAY = 0 ;
 124         -:  119:
 125         -:  120:  //char output[SIZE_NAME_FILE] ;
 126         -:  121:
 127         1:  122:  if (DISPLAY)
 128         -:  123:    {
 129     #####:  124:      recopie_vecteur(Image_in[0], Image_tmp[0], I_dim*J_dim) ;
 130     #####:  125:      affiche_snake(Image_tmp, Snake, 255, 0, Liste_pixel_segment) ;
 131     #####:  126:      imagesc(Image_tmp, I_dim, J_dim) ;
 132         -:  127:      //sprintf(output, "im%.3d.pgm", 0) ;
 133         -:  128:      //write_int2pgm(Image_tmp, I_dim, J_dim, output, 1) ;
 134         -:  129:    }
 135         -:  130:
 136         -:  131:  /* init la pdf des valeurs des niveaux de gris */
 137         1:  132:  PDF = argv[2] ;
 138         1:  133:  if ((PDF == NULL) | (*PDF == '0' ))
 139         -:  134:    {
 140         1:  135:      FCN_codage_gl = codage_niveau_gris_hyp_gaussienne ;
 141         1:  136:      if (Verbose) printf("Hypothese GAUSSIENNE\n") ;
 142         -:  137:    }
 143         -:  138:  else
 144         -:  139:    {
 145     #####:  140:      FCN_codage_gl = codage_niveau_gris_hyp_gamma ;
 146     #####:  141:      if (Verbose) printf("Hypothese GAMMA\n") ;
 147         -:  142:    }
 148         -:  143:
 149         -:  144:
 150         -:  145:  /* debug : tests fonctions*/
 151         -:  146:  double lcode_gl ;
 152         1:  147:  if (Verbose)
 153         -:  148:    {
 154         1:  149:      lcode_gl = FCN_codage_gl(Stat_sum_1,Stat_sum_x,Stat_sum_x2,N_dim,SUM_X,SUM_X2) ;
 155         1:  150:      printf("\nINIT : longueur de codage de gl : %lf  (%d)\n", lcode_gl, Stat_sum_1) ;
 156         -:  151:    }
 157         -:  152:
 158         -:  153:  // variables de debug
 159         -:  154:  int nb_move, nb_newnode, iter ;
 160         1:  155:  int nb_move_total=0, nb_test, nb_test_total=0 ;
 161         1:  156:  int NB_iter_max = 10 ;
 162         1:  157:  int Dist_min_entre_noeud = 16 ; /* ou l'on autorise l'ajout de noeud */
 163         1:  158:  int Pas = 8 ;
 164         -:  159:
 165         1:  160:  if (Verbose) {
 166         1:  161:  printf("nb noeuds : %d\n", Nb_noeud) ;
 167         1:  162:  tic(&chrono_all, NULL) ;
 168         -:  163:  }
 169        11:  164:  for (iter=1; iter<=NB_iter_max; iter++)
 170         -:  165:    {
 171        10:  166:      if (VERBOSE)
 172         -:  167:        {
 173        10:  168:          printf("\n#%d\n", iter) ;
 174        10:  169:          tic(&chrono, NULL) ;
 175         -:  170:        }
 176        10:  171:      nb_move = move_snake_mv(Snake, Pas,
 177         -:  172:                              &Stat_sum_1, &Stat_sum_x, &Stat_sum_x2,
 178         -:  173:                              N_dim, SUM_X, SUM_X2,
 179         -:  174:                              Images_cumul, Liste_pixel_segment,
 180         -:  175:                              I_dim-1, J_dim-1, &nb_test,
 181         -:  176:                              FCN_codage_gl) ;
 182        10:  177:      nb_move_total += nb_move ;
 183        10:  178:      nb_test_total += nb_test ;
 184         -:  179:
 185        10:  180:      if (iter==1) Pas = 4 ;
 186        10:  181:      if (iter==2) Pas = 2 ;
 187        10:  182:      if (iter==3) Pas = 1 ;
 188         -:  183:
 189        10:  184:      if (DISPLAY)
 190         -:  185:        {
 191     #####:  186:          recopie_vecteur(Image_in[0], Image_tmp[0], I_dim*J_dim) ;
 192     #####:  187:          affiche_snake(Image_tmp, Snake, 255, 0, Liste_pixel_segment) ;
 193     #####:  188:          imagesc(Image_tmp, I_dim, J_dim) ;
 194         -:  189:          //sprintf(output, "im%.3d.pgm", iter) ;
 195         -:  190:          //write_int2pgm(Image_tmp, I_dim, J_dim, output, 1) ;
 196         -:  191:        }
 197         -:  192:
 198        10:  193:      nb_newnode = double_nb_noeud_snake(Snake, Images_cumul, Liste_pixel_segment,
 199         -:  194:                                         &Stat_sum_1, &Stat_sum_x, &Stat_sum_x2,
 200         -:  195:                                         Dist_min_entre_noeud, &Nb_noeud) ;
 201        10:  196:      if (nb_newnode==0) break ;
 202         -:  197:
 203        10:  198:      if (VERBOSE)
 204         -:  199:        {
 205        10:  200:          toc(chrono, "temps sequence move") ;
 206        10:  201:          printf("nb deplacements    : %d\n", nb_move) ;
 207        10:  202:          printf("nb deplacements total/test   : %d/%d\n", nb_move_total, nb_test_total) ;
 208        10:  203:          printf("nb nouveaux noeuds : %d (total: %d)\n", nb_newnode, Nb_noeud) ;
 209        10:  204:          lcode_gl = FCN_codage_gl(Stat_sum_1,Stat_sum_x,Stat_sum_x2,N_dim,SUM_X,SUM_X2) ;
 210        10:  205:          printf("\nlongueur de codage de gl : %lf  (%d)\n", lcode_gl, Stat_sum_1) ;
 211         -:  206:        }
 212         -:  207:    }
 213         -:  208:
 214         1:  209:  if (Verbose) {
 215         1:  210:  toc(chrono_all, "temps move mv") ;
 216         1:  211:  lcode_gl = FCN_codage_gl(Stat_sum_1, Stat_sum_x, Stat_sum_x2, N_dim, SUM_X, SUM_X2) ;
 217         1:  212:  printf("\nFIN : longueur de codage de gl : %lf  (%d)\n", lcode_gl, Stat_sum_1) ;
 218         1:  213:  printf("nb noeuds : %d, nb_iter : %d\n", Nb_noeud, iter) ;
 219         1:  214:  printf("nb deplacements total/test   : %d/%d\n", nb_move_total, nb_test_total) ;
 220         -:  215:  }
 221         -:  216:
 222         -:  217:
 223         1:  218:  if (Display) {
 224         -:  219:  /* debug : affichage snake */
 225         1:  220:  affiche_snake(Image_in, Snake, 255, 0, Liste_pixel_segment) ;
 226         1:  221:  imagesc(Image_in, I_dim, J_dim) ;
 227         -:  222:  }
 228         -:  223:
 229         -:  224:  /* Delete */
 230         1:  225:  del_matrix_int(Image_in, I_dim) ;
 231         1:  226:  del_matrix_pixel_cumul_sse(Images_cumul, I_dim) ;
 232         1:  227:  free(Liste_pixel_segment) ;
 233         -:  228:  /* del_snake(Snake) */
 234         1:  229:  return 1 ;
 235         -:  230:}
 236         -:  231: