lchanfrein_imafl.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 
00045 #include <stdio.h>
00046 #include <stdlib.h>
00047 #include <math.h>
00048 #include "image.h"
00049 #include "proto2D.h"
00050 #include "chanfrein_imafl.h"
00051 
00052 
00053 #define   max(x,y)  (((x)>(y))?(x):(y))
00054 #define   min(x,y)  (((x)<(y))?(x):(y))
00055 /*#define   abs(x) ((x>0)?x:-x)*/
00056 
00057 /*typedef  unsigned char Byte;*/
00058 
00059 
00060 
00061 /* ****************************************************************************/
00062 /*                             FONCTION MINIMUN                               */
00063 /*   Cette fonction retourne le minimum d'un tableau de 25 elements .         */
00064 /*   ainsi que sa position x0 et y0                                           */
00065 /* ****************************************************************************/
00066 
00067 
00068 float  minimum( float masque[5][5], unsigned int *x0, unsigned int *y0)
00069 {
00070      register int i,j;
00071      float mini, mini1;
00072 
00073      mini=masque[0][0];
00074      *x0 = 0;
00075      *y0 = 0;
00076      for ( i=0 ; i<5 ; i++ )
00077          for ( j=0 ; j<5 ; j++ )
00078          {            
00079              mini1=min(masque[i][j],mini);
00080              if (mini1 < mini)
00081              {
00082                 mini = mini1;
00083                 *x0 = i;
00084                 *y0 = j;
00085              }  
00086          }
00087 
00088          return   mini;               
00089      }
00090 
00091 
00092 /* ***************************************************************************/
00093 /*                       FIN  FONCTION MINIMUN                               */
00094 /* ***************************************************************************/
00095 
00096 
00097 /* ***************************************************************************/
00098 /*                             FONCTION DISTANCE                             */
00099 /*   Cette fonction calcule la distance de chaque pixel d'une image au       */
00100 /*                    fond ( Background ).                                   */
00101 /* ***************************************************************************/
00102 
00103 void  distance(imau1 *im1, imafl *im2)
00104 {
00105 
00106        register int   x,y;
00107        float          maximum,niveau,recop,recop1;
00108        int            w,compt,fin;
00109        unsigned int   x1,y1;
00110        double         val;
00111        float          valeur,inter;
00112        float          tt,vv,s;
00113        float          n1,n2,n3,num,denom;
00114        float          delta1,delta2,delta3;
00115        float          A,B,C,D,E;
00116        int            ydebut;
00117        float          *ima_dist;
00118        float          *ima_dist1;
00119        float          *ima_sir;
00120        float          fen[5][5];
00121        int            largeur, hauteur;
00122        unsigned char  *ima1;
00123        float          *ima2;
00124 
00125                /*-----------------------------------------------------*/
00126                /*      CALCUL DES COEFFICIENTS OPTIMAUX REELS  A,B,C,D,E.    */
00127                /*-----------------------------------------------------*/
00128 
00129        largeur = im1->nc;
00130        hauteur = im1->nr;
00131        ima1 = im1->p[0];
00132        ima2 = im2->p[0];
00133 
00134        ima_dist=(float *)calloc(largeur*hauteur,sizeof(float));
00135        ima_dist1=(float *)calloc(largeur*hauteur,sizeof(float));
00136        ima_sir=(float *)calloc(largeur*hauteur,sizeof(float)); 
00137          
00138        
00139 
00140        A=1.0;
00141        B=sqrt(2.0);
00142        C=sqrt(5.0);
00143        /* Comme le Maillage est CARRE */
00144        D=A;
00145        E=C;
00146 
00147 
00148        printf("Coefficients reels du masque 5x5 de Chanfrein (Maillage Carre)\n");
00149        printf("A=%d  B=%d  C=%d\n",A,B,C); 
00150 
00151 
00152             /*----------------------------------------------*/
00153             /*          MISE EN FORME DE L'IMAGE SOURCE     */
00154             /*----------------------------------------------*/
00155 /* On traite une image binaire: Objet = 0,  Fond = 255   *****/
00156 /* les points du fond initialement a 255 sont mis a l'infini ***/
00157 /* les autres, donc l'objet reste a 0                   ***/
00158    
00159        fin=(largeur)*(hauteur);
00160 
00161            printf("largeur= %d  hauteur= %d\n",largeur,hauteur);       
00162       
00163        for ( x=0 ; x<fin ; x++ )
00164            {
00165            if ( ima1[x]!=0)
00166            ima_sir[x]=20000;
00167            else  ima_sir[x]=0.0; 
00168            }
00169 
00170   
00171 /* ima_sir = image de reference utiliser pour calculer l'image de distance **/
00172 /* ima_dist1 = image de distance apres le passage du masque_avant     *******/
00173 /* ima_dist  = image de distance finale   *****/      
00174 
00175            /*----------------------------------------------*/
00176            /*               BOUCLE ALLER                   */
00177            /*  Balayage de gche a drte et de haut en bas   */
00178            /*----------------------------------------------*/
00179         
00180        for ( y=2 ; y<hauteur-2 ; y++ )
00181            for ( x=2 ; x<largeur-2 ; x++ )
00182                {
00183                w=x+y*largeur;
00184                if (ima_sir[w]!=0.0)
00185                {
00186                                 /* comparaison avec le masque avant  ****/                                               
00187                   fen[0][0]=(2*B)+(ima_sir[w-2*largeur-2]);
00188                   fen[0][1]=(E)+(ima_sir[w-2*largeur-1]);  
00189                   fen[0][2]=(2*D)+(ima_sir[w-2*largeur]);  
00190                   fen[0][3]=(E)+(ima_sir[w-2*largeur+1]);  
00191                   fen[0][4]=(2*B)+(ima_sir[w-2*largeur+2]);  
00192                    
00193                   fen[1][0]=(C)+(ima_sir[w-largeur-2]);      
00194                   fen[1][1]=(B)+(ima_sir[w-largeur-1]);    
00195                   fen[1][2]=(D)+(ima_sir[w-largeur]);    
00196                   fen[1][3]=(B)+(ima_sir[w-largeur+1]);   
00197                   fen[1][4]=(C)+(ima_sir[w-largeur+2]);
00198 
00199                   fen[2][0]=(2*A)+(ima_sir[w-2]);
00200                   fen[2][1]=(A)+(ima_sir[w-1]);    
00201                   fen[2][2]=20000;   
00202                   fen[2][3]=20000;                 
00203                   fen[2][4]=20000; 
00204                      
00205                   fen[3][0]=20000;                
00206                   fen[3][1]=20000;                 
00207                   fen[3][3]=20000;                  
00208                   fen[3][4]=20000;
00209                   fen[3][2]=20000;
00210                   fen[4][0]=fen[4][1]=fen[4][2]=fen[4][3]=fen[4][4]=20000;
00211  
00212                   
00213                   ima_dist1[w]=minimum(fen,&x1,&y1);
00214                   ima_sir[w]=ima_dist1[w];
00215                 }
00216                 else ima_dist[w] = 0.0;
00217                }                        /*    fin du for */
00218 
00219 
00220       /*-------------------------------------------------------*/             
00221       /*                     BOUCLE RETOUR                     */
00222       /*  Balayage de l'image de drte a gche et de bas en haut */
00223       /*-------------------------------------------------------*/
00224         
00225        for ( y=hauteur-3 ; y>1 ; y-- )
00226            for ( x=largeur-3 ; x>1 ; x-- )
00227                {
00228                w=x+(y)*largeur;
00229                if (ima_sir[w]!=0.0)
00230                {
00231                                 /* comparaison avec le masque arriere  ****/
00232 
00233                   fen[4][0]=(2*B)+(ima_sir[w+2*largeur-2]);
00234                   fen[4][1]=(E)+(ima_sir[w+2*largeur-1]);  
00235                   fen[4][2]=(2*D)+(ima_sir[w+2*largeur]);  
00236                   fen[4][3]=(E)+(ima_sir[w+2*largeur+1]);  
00237                   fen[4][4]=(2*B)+(ima_sir[w+2*largeur+2]);  
00238                    
00239                   fen[3][0]=(C)+(ima_sir[w+largeur-2]);      
00240                   fen[3][1]=(B)+(ima_sir[w+largeur-1]);    
00241                   fen[3][2]=(D)+(ima_sir[w+largeur]);    
00242                   fen[3][3]=(B)+(ima_sir[w+largeur+1]);   
00243                   fen[3][4]=(C)+(ima_sir[w+largeur+2]);
00244 
00245                   fen[2][4]=(2*A)+(ima_sir[w+2]);
00246                   fen[2][3]=(A)+(ima_sir[w+1]);    
00247                   fen[2][2]=20000;   
00248                   fen[2][0]=20000;                 
00249                   fen[2][1]=20000;                      
00250                   fen[0][0]=fen[0][1]=fen[0][2]=fen[0][3]=fen[0][4]=20000;
00251 
00252                   fen[1][0]=20000;                  
00253                   fen[1][1]=20000;
00254                   fen[1][3]=20000;                 
00255                   fen[1][4]=20000;
00256                   fen[1][2]=20000;
00257              
00258                   recop1=minimum(fen,&x1,&y1);
00259                   recop=ima_dist1[w];                 
00260                   ima_dist[w]=min(recop,recop1);
00261                   ima_sir[w]=ima_dist[w];
00262                 }
00263                 else ima_dist[w]=0.0;        
00264                              
00265               }              /*    fin du for */
00266 
00267 
00268 
00269         for ( y=(fin-1) ; y>=0 ; y-- )
00270             ima2[y] = ima_dist[y];
00271       
00272 
00273 
00274 
00275         printf("\nFIN IMAGE DE DISTANCE: \n");
00276         printf("\n");
00277                 
00278         cfree(ima_sir);
00279         cfree(ima_dist);
00280         cfree(ima_dist1);  
00281 
00282 }                      /*    fin de distance    */
00283 
00284 
00295 int chanfrein_imafl_init( imau1 *imO, imafl *imRes)
00296 {
00297         imRes->nr = imO->nr;
00298         imRes->nc = imO->nc;
00299         alloc_imafl(imRes);
00300     
00301 }
00302 
00312 int chanfrein_imafl_calc( imau1 *imO, imafl *imRes)
00313 {
00314     distance( imO, imRes);
00315 }
00316 

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