lcontourRSO.c

00001 /*
00002 *    Copyright (c) 2007. The BATI team. All right reserved.
00003 *
00004 *    This file is part of BATI library.
00005 *
00006 *    BATI library is free software: you can redistribute it and/or modify
00007 *    it under the terms of the GNU General Public License as published by
00008 *    the Free Software Foundation, either version 3 of the License, or
00009 *    (at your option) any later version.
00010 *
00011 *    BATI library  is distributed in the hope that it will be useful,
00012 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 *    GNU General Public License for more details.
00015 *
00016 *    You should have received a copy of the GNU General Public License
00017 *    along with BATI library.  If not, see <http://www.gnu.org/licenses/>.
00018 */
00019 /* **************************** lcontourRSO.c ****************************/
00020 /*                                                                    */
00021 /* ********************************************************************/
00022 
00049 #include "image.h"
00050 #include "proto2D.h"
00051 #include "contourRSO.h"
00052 /* #include "limits.h" */
00053 #include <stdlib.h>
00054 #include <string.h>
00055 
00056 #define MININV(a) ( (a) <= 1. ? (a) : 1./(a) ) 
00057 #define FLT_MAX         3.402823466E+38F  /* max decimal value of a "float" */
00058 
00059 /* **************** fonctions locales ********************* */
00060 
00061 /* application d'un masque, retourne rapport moy1/moy2 ******** */
00062 float appl_masque12(imau2 im0, imau1 msq, int i, int j, float *tab){
00063   int k, l, m, n, dim;
00064   float tmp1, tmp2;
00065   float rap;
00066 
00067   tmp1 = 0;
00068   tmp2 = 0;
00069   dim = msq.nr;
00070   for(m=-(dim/2);m<(dim/2)+1;m++)
00071       for(n=-(dim/2);n<(dim/2)+1;n++){
00072               if(msq.p[m+(dim/2)][n+(dim/2)] == 1){
00073                   tmp1 += tab[im0.p[i+m][j+n]];
00074               }
00075               if(msq.p[m+(dim/2)][n+(dim/2)] == 2){
00076                   tmp2 += tab[im0.p[i+m][j+n]];
00077               }
00078           }
00079   if(tmp2 == 0.){
00080       if(tmp1 == 0.)
00081           rap = 1.;
00082       else
00083           rap = FLT_MAX;
00084   }
00085   else
00086       rap = tmp1/tmp2;
00087   return(rap);
00088 }
00089 
00090 /* selection de la direction [0|1|32|64 ...  224] et la valeur [0, 1] du ratio */ 
00091 void valdirmax(float v, float h, float dp, float ds, float *ptval, pixu1 *ptdir){
00092     float tmp;
00093 
00094     if(v < 1.){
00095         *ptval = v;
00096         *ptdir = 128;
00097     }
00098     else if (v > 1.){
00099         *ptval = 1./v;
00100         *ptdir = 1;     
00101     }
00102     else{
00103         *ptval = 1.;
00104         *ptdir = 0;
00105     }
00106 
00107     tmp = MININV(h);
00108     if(tmp < *ptval){
00109         *ptval = tmp;
00110         if(h<1.)
00111             *ptdir = 192;
00112         else
00113             *ptdir = 64;
00114     }
00115 
00116     tmp = MININV(dp);
00117     if(tmp < *ptval){
00118         *ptval = tmp;
00119         if(dp<1.)
00120             *ptdir = 224;
00121         else
00122             *ptdir = 96;
00123     }
00124 
00125     tmp = MININV(ds);
00126     if(tmp < *ptval){
00127         *ptval = tmp;
00128         if(ds<1.)
00129             *ptdir = 160;
00130         else
00131             *ptdir = 32;
00132     }
00133 }
00134 
00135 /* test si contour est max local dans la direction du gradient, retourne 1 si oui, 0 sinon */
00136 int maxlocgrad(float val, float dir, int j, contourRSO_t *des){
00137     float v1, v2;
00138 
00139     if(dir == 0)
00140         return(0);
00141     else if( (dir == 1) || (dir == 128) ){ /* coutour vertical */
00142         v1 = MININV(des->rapv.p[1][j-1]);
00143         v2 = MININV(des->rapv.p[1][j+1]);
00144     }
00145     else if( (dir == 64) || (dir == 192) ){ /* coutour horizontal */
00146         v1 = MININV(des->raph.p[0][j]);
00147         v2 = MININV(des->raph.p[2][j]);
00148     }
00149     else if( (dir == 32) || (dir == 160) ){ /* coutour diag princip */
00150         v1 = MININV(des->rapdp.p[0][j+1]);
00151         v2 = MININV(des->rapdp.p[2][j-1]);
00152     }
00153     else if( (dir == 96) || (dir == 224) ){ /* coutour diag second */
00154         v1 = MININV(des->rapds.p[0][j-1]);
00155         v2 = MININV(des->rapds.p[2][j+1]);
00156     }
00157     else{
00158         printf("\n\n>> ERREUR maxlocgrad : direction %d inconnue\n\n", (int)dir);
00159         exit(1);
00160     }
00161     
00162     if( (val <= v1) && (val <= v2) )
00163         return(1);
00164     else
00165         return(0);
00166 }
00167 
00168 /* ****************  *********  LECTURE  *******************************/
00179 param *contourRSO_lect(contourRSO_t *des, param *ptp, char *debq){
00180   char question[500];
00181 
00182   sprintf(question, "%s dimension fenetre d'analyse (impair)", debq); 
00183   lec_param(question, ptp);
00184   des->dim = atoi(ptp->rep);
00185   ptp = ptp->next;
00186 
00187   sprintf(question, "%s sauver imagette masque (oui=1/non=0)", debq);
00188   lec_param(question, ptp);
00189   des->qsauver = atoi(ptp->rep);
00190   ptp = ptp->next;
00191 
00192   sprintf(question, "%s selection des contours max locaux (oui=1/non=0)", debq);
00193   lec_param(question, ptp);
00194   des->maxloc = atoi(ptp->rep);
00195   ptp = ptp->next;
00196 
00197   return(ptp);
00198 }
00199 
00200 /* *************************  INITIALISATION  ***************************/
00213 int contourRSOu2_init(contourRSO_t *des, imau2 im0, imafl *imval, imau1 *imdir){
00214   int  i, j, k, n;
00215   
00216   /* images resultat */ 
00217   imval->nc = im0.nc;
00218   imval->nr = im0.nr;
00219   imdir->nc = im0.nc; 
00220   imdir->nr = im0.nr;
00221   sprintf(imval->nom, "%s_ctr_val%dx%d", im0.nom, des->dim, des->dim); 
00222   sprintf(imdir->nom, "%s_ctr_dir%dx%d", im0.nom, des->dim, des->dim); 
00223   alloc_imafl(imval);
00224   alloc_imau1(imdir); 
00225 
00226   /* variables de l'operateur */
00227 
00228   /* *********************** intializari masti**********************/
00229   /* initialization masque vertical  */
00230   des->msqv.nc = des->dim; 
00231   des->msqv.nr = des->dim;
00232   alloc_imau1(&(des->msqv));
00233   for(i=0; i<des->dim; i++)
00234       for(j=0; j<des->dim; j++){des->msqv.p[i][j]=0;}
00235 
00236   /* initialization masque horizontal  */
00237   des->msqh.nc = des->dim; 
00238   des->msqh.nr = des->dim;
00239   alloc_imau1(&(des->msqh));
00240   for(i=0; i<des->dim-1; i++)
00241       for(j=0; j<des->dim-1; j++){des->msqh.p[i][j]=0;}
00242 
00243   /* initialization masque diagonal principal */
00244   des->msqdp.nc = des->dim; 
00245   des->msqdp.nr = des->dim;
00246   alloc_imau1(&(des->msqdp));
00247   for(i=0; i<des->dim-1; i++)
00248       for(j=0; j<des->dim-1; j++){des->msqdp.p[i][j]=0;}
00249 
00250   /* initialization masque diagonal secondaire */
00251   des->msqds.nc = des->dim; 
00252   des->msqds.nr = des->dim;
00253   alloc_imau1(&(des->msqds));
00254   for(i=0; i<des->dim-1; i++)
00255       for(j=0; j<des->dim-1; j++){des->msqds.p[i][j]=0;}
00256   
00257   /* buuffers pour selection du max local */
00258   if(des->maxloc == 1){
00259       des->rapv.nc = im0.nc; 
00260       des->rapv.nr = 3;
00261       alloc_imafl(&(des->rapv));
00262       for(i=0; i<3; i++)
00263           for(j=0; j<im0.nc; j++){des->rapv.p[i][j]=1.;}
00264 
00265       des->raph.nc = im0.nc; 
00266       des->raph.nr = 3;
00267       alloc_imafl(&(des->raph));
00268       for(i=0; i<3; i++)
00269           for(j=0; j<im0.nc; j++){des->raph.p[i][j]=1.;}
00270 
00271       des->rapdp.nc = im0.nc; 
00272       des->rapdp.nr = 3;
00273       alloc_imafl(&(des->rapdp));
00274       for(i=0; i<3; i++)
00275           for(j=0; j<im0.nc; j++){des->rapdp.p[i][j]=1.;}
00276 
00277       des->rapds.nc = im0.nc; 
00278       des->rapds.nr = 3;
00279       alloc_imafl(&(des->rapds));
00280       for(i=0; i<3; i++)
00281           for(j=0; j<im0.nc; j++){des->rapds.p[i][j]=1.;}
00282   }
00283 
00284   /* ******************* fin intialization ***********************/
00285 
00286   /* ************* calcul du masque ************* */
00287 
00288   /* calcul  masti verticale */
00289   for(i=0; i<des->dim; i++)
00290       for(j=0; j<des->dim/2; j++){
00291           des->msqv.p[i][j] = 1;
00292       }
00293   for(i=0; i<des->dim; i++)
00294       for(j = des->dim/2+1; j<des->dim ; j++){
00295           des->msqv.p[i][j] = 2;
00296       }
00297 
00298   /* calcul masti orizontale */
00299   for(i=0; i<(des->dim/2); i++)
00300       for(j=0; j<des->dim; j++){
00301           des->msqh.p[i][j] = 1;
00302       }
00303   for(i=(des->dim/2 + 1); i<des->dim; i++)
00304       for(j=0;j<des->dim; j++){
00305           des->msqh.p[i][j] = 2;
00306       }
00307 
00308    /* calcul masti diagonala principala * */
00309    n=1; 
00310    for(i=0;i<des->dim-1; i++){ 
00311        n++; 
00312        for(j=n-1; j<des->dim; j++){
00313            des->msqdp.p[i][j]=1;
00314        } 
00315    } 
00316    n=1; 
00317    for(i=1;i<des->dim; i++){ 
00318        n++; 
00319        for(j=0; j<n-1; j++){
00320            des->msqdp.p[i][j]=2;
00321        } 
00322    }   
00323 
00324    /* calcul masti diagonala secundara * */
00325    n=1; 
00326    for(i=0; i<des->dim-1; i++){ 
00327        n++; 
00328        for(j=0; j<des->dim-n+1; j++){
00329            des->msqds.p[i][j]=1;
00330        } 
00331    } 
00332    n=1;  
00333    for(i=1; i<des->dim; i++){  
00334        n++;  
00335        for(j=des->dim-1; j>des->dim-n; j--){
00336            des->msqds.p[i][j]=2;
00337        }  
00338    }  
00339 /* ************* fin masques ****************/
00340    
00341    if(des->qsauver == 1){
00342        write_ima_t wriv;
00343        write_ima_t wrih;
00344        write_ima_t wridp;
00345        write_ima_t wrids;
00346        strcpy(wriv.nom, "msqv");
00347        strcpy(wriv.ext, "ima"); 
00348        strcpy(wrih.nom, "msqh");
00349        strcpy(wrih.ext, "ima"); 
00350        strcpy(wridp.nom, "msqdp");
00351        strcpy(wridp.ext, "ima"); 
00352        strcpy(wrids.nom, "msqds");
00353        strcpy(wrids.ext, "ima"); 
00354        write_ima_init(&wriv);
00355        write_ima_init(&wrih);
00356        write_ima_init(&wridp);
00357        write_ima_init(&wrids);
00358        write_imau1_ferm(&wriv, des->msqv);
00359        write_imau1_ferm(&wrih, des->msqh);
00360        write_imau1_ferm(&wridp, des->msqdp);
00361        write_imau1_ferm(&wrids, des->msqds);
00362    }
00363 }
00364 /* *************************  CALCUL  ***************************/
00376 int contourRSOu2_calc(contourRSO_t *des, imau2 im0, imafl *imval, imau1 *imdir){
00377   int i, j, dims2, k;
00378   float val, tab_car[65536], v, h, dp, ds;
00379   float *tmp_ptfl;
00380   pixu1 dir;
00381 
00382   dims2 = des->dim/2;
00383   for(i=0; i< 65536; i++)
00384       tab_car[i] = (float)i*(float)i;
00385   
00386   for(i=0; i<im0.nr; i++)
00387       for(j=0; j<im0.nc; j++){
00388           imval->p[i][j] = 1.;
00389           imdir->p[i][j] = 0;
00390       }
00391 
00392   /*  CALCUL AVEC BUFFERISATION POUR SELECTION DES MAX LOCAUX */
00393   if( des->maxloc == 1){
00394       /* premiere ligne calculable */
00395       i = dims2;
00396       for(j=dims2; j<im0.nc - dims2; j++){
00397           des->rapv.p[1][j] = appl_masque12(im0, des->msqv, i, j, tab_car);
00398           des->raph.p[1][j] = appl_masque12(im0, des->msqh, i, j, tab_car);
00399           des->rapdp.p[1][j] = appl_masque12(im0, des->msqdp, i, j, tab_car);
00400           des->rapds.p[1][j] = appl_masque12(im0, des->msqds, i, j, tab_car);
00401       }
00402 
00403   /* rapport sur ligne i, resultat maxloc sur ligne k=i-1 */
00404       for(i=dims2+1; i<im0.nr - dims2; i++){
00405           k = i-1;
00406           for(j=dims2; j<im0.nc - dims2; j++){
00407               des->rapv.p[2][j] = appl_masque12(im0, des->msqv, i, j, tab_car);
00408               des->raph.p[2][j] = appl_masque12(im0, des->msqh, i, j, tab_car);
00409               des->rapdp.p[2][j] = appl_masque12(im0, des->msqdp, i, j, tab_car);
00410               des->rapds.p[2][j] = appl_masque12(im0, des->msqds, i, j, tab_car);
00411           }
00412           for(j=dims2; j<im0.nc - dims2; j++){
00413               valdirmax(des->rapv.p[1][j], des->raph.p[1][j], des->rapdp.p[1][j],
00414                         des->rapds.p[1][j], &val, &dir);
00415               if( maxlocgrad(val, dir, j, des) ){
00416                       imval->p[k][j] = val;
00417                       imdir->p[k][j] = dir;           
00418               }
00419           }
00420           /* permutation des lignes des 4 buffers */
00421           tmp_ptfl = des->rapv.p[0];
00422           des->rapv.p[0] = des->rapv.p[1];
00423           des->rapv.p[1] = des->rapv.p[2];
00424           des->rapv.p[2] = tmp_ptfl;
00425           tmp_ptfl = des->raph.p[0];
00426           des->raph.p[0] = des->raph.p[1];
00427           des->raph.p[1] = des->raph.p[2];
00428           des->raph.p[2] = tmp_ptfl;
00429           tmp_ptfl = des->rapdp.p[0];
00430           des->rapdp.p[0] = des->rapdp.p[1];
00431           des->rapdp.p[1] = des->rapdp.p[2];
00432           des->rapdp.p[2] = tmp_ptfl;
00433           tmp_ptfl = des->rapds.p[0];
00434           des->rapds.p[0] = des->rapds.p[1];
00435           des->rapds.p[1] = des->rapds.p[2];
00436           des->rapds.p[2] = tmp_ptfl;
00437       }
00438       /* resultat maxloc sur derniere ligne */
00439       k = i-1;
00440           for(j=dims2; j<im0.nc - dims2; j++){
00441               des->rapv.p[2][j] = 1.;
00442               des->raph.p[2][j] = 1.;
00443               des->rapdp.p[2][j] = 1.;
00444               des->rapds.p[2][j] = 1.;
00445           }
00446           for(j=dims2; j<im0.nc - dims2; j++){
00447               valdirmax(des->rapv.p[1][j], des->raph.p[1][j], des->rapdp.p[1][j],
00448                         des->rapds.p[1][j], &val, &dir);
00449               if( maxlocgrad(val, dir, j, des) ){
00450                       imval->p[k][j] = val;
00451                       imdir->p[k][j] = dir;           
00452               }
00453           }
00454   }
00455 
00456   /*  CALCUL DIRECT  SANS SELECTION DES MAX LOCAUX */
00457   else{ 
00458       for(i=dims2; i<im0.nr - dims2; i++)
00459           for(j=dims2; j<im0.nc - dims2; j++){
00460               v = appl_masque12(im0, des->msqv, i, j, tab_car);
00461               h = appl_masque12(im0, des->msqh, i, j, tab_car);
00462               dp = appl_masque12(im0, des->msqdp, i, j, tab_car);
00463               ds = appl_masque12(im0, des->msqds, i, j, tab_car);
00464               valdirmax(v, h, dp, ds, imval->p[i]+j, imdir->p[i]+j);
00465           }
00466   }
00467 }
00468 

Generated on Tue Apr 22 13:31:04 2008 for ima2D by  doxygen 1.5.3