segct.c

image processing including fourier,wavelet,segmentation etc.

             else                {      /*   a-L1-b  et   c-L2-d  ,li=a-d-c-b */
                for (li=reg->Lbords;li->suiv!=L2;li=li->suiv) {
                    if (li->suiv==L1)   li->suiv=L2->suiv;
                    if (li->suiv==NULL) li->suiv=regvois->Lbords;
                }
                li->suiv=L1->suiv;
                li=reg->Lbords;
             }


  reg->Lbords=li;
  /* Fin mise en place des bords                                    */
}

void ElimBordeSom(bord)           /* Elimine 'bord' des listes de bord des   */
BORDPTR bord;                     /*  sommets des comp. cnxes. de 'bord'     */
{
  LI_BORDSPTR li;
  BORDCONNEXEPTR cnxeptr; 

  for(cnxeptr=bord->cnxe;cnxeptr!=NULL;cnxeptr=cnxeptr->suiv) {
    li=cnxeptr->sa->Lbords;
    if (li->bord==bord)    
       cnxeptr->sa->Lbords=li->suiv;
    else {
       for ( ;(li->suiv!=NULL)&&(li->suiv->bord!=bord);li=li->suiv) ;
       if(li->suiv!=NULL)     /* 'bord' n'existe plus dans la liste de sa */
            li->suiv=li->suiv->suiv;
    }


    if (cnxeptr->sa==cnxeptr->sb) break; /* On elimine une boucle */


    li=cnxeptr->sb->Lbords;
    if (li->bord==bord)
       cnxeptr->sb->Lbords=li->suiv;
    else {
       for ( ;(li->suiv!=NULL)&&(li->suiv->bord!=bord);li=li->suiv) ;
       if(li->suiv!=NULL)    /* 'bord' n'existe plus dans la liste de sb */
            li->suiv=li->suiv->suiv;
    }
  }
}

void DegreSommet(som)            /* Calcule le degre du sommet 'som'         */
SOMMETPTR som;                   /* Suivant les cas on procede a la suite    */
{
  unsigned short degre;
  LI_BORDSPTR li;
  static void Union1Bord(),Union2Bords();

  degre=0;
  for(li=som->Lbords;li!=NULL;li=li->suiv) degre++;

  if (degre==0) image.nbsommets--;
  if (degre==1) Union1Bord(som);
  if (degre==2) Union2Bords(som);
}

void Union1Bord(som)               /* Si 'som' appartient a deux composantes */
SOMMETPTR som;                     /*  cnxes. d'un meme bord on reunit ces   */
{                                  /*  parties connexes                      */
  BORDPTR bord;
  BORDCONNEXEPTR bcnxe,bcnxe1,bcnxe2;
  static LI_PIXELSPTR LiPixelsUnion();
  unsigned short compteur;

  bord=som->Lbords->bord;
  compteur=0;
  for(bcnxe=bord->cnxe;bcnxe!=NULL;bcnxe=bcnxe->suiv)
    if((bcnxe->sa==som)||(bcnxe->sb==som)) compteur++;

  if (compteur==1)  return;             /* 'som' est sur le bord de l'image  */

  if (compteur==0)  return;  /* 'som' est deja enleve de la liste des bords  */
     

  image.nbsommets--;      /*On enleve 'som'       */

  /* Determination des comp. cnxes. de sommet som */
  /*                                     */
  /*     (r1)            (r1)     */
  /*  sb ----> sa  $  sb ----> sa */
  /*    bcnxe1   :som:  bcnxe2    */
  /********************************/
  for(bcnxe=bord->cnxe;bcnxe!=NULL;bcnxe=bcnxe->suiv) {
        if (bcnxe->sa==som) bcnxe1=bcnxe;
        if (bcnxe->sb==som) bcnxe2=bcnxe;
  }

  /* Reunir les deux bcnxes dont som est un sommet dans bcnxe1 */
  bcnxe1->sa=bcnxe2->sa;
  bcnxe1->lba=LiPixelsUnion(bcnxe1->lba,bcnxe2->lba);
  bcnxe1->lab=LiPixelsUnion(bcnxe2->lab,bcnxe1->lab);
  if (bord->cnxe==bcnxe2) 
        bord->cnxe=bcnxe2->suiv;
  else {
        for(bcnxe=bord->cnxe;bcnxe->suiv!=bcnxe2;bcnxe=bcnxe->suiv) ;
        bcnxe->suiv=bcnxe2->suiv;
  }
}



void Union2Bords(som)              /* Si som est entre deux bords exactement */
SOMMETPTR som;                     /*  on reunit ces bords en un bord unique */
{
  char i;
  short dir_bcnxe1,dir_bcnxe2;
  static void Repointer(),ElimBordeReg();
  SOMMETPTR sa_old;
  BORDPTR bord1,bord2,bord;
  BORDCONNEXEPTR bcnxe1,bcnxe2,bcnxe;
  LI_BORDSPTR li;
  static LI_PIXELSPTR LiPixelsUnion();
  LI_PIXELSPTR lab_old;

  bord1=som->Lbords->bord;
  bord2=som->Lbords->suiv->bord;



 /** Est-ce que 'som' est le sommet d'un bord ferme,lacet (au moins) **/
 /* Dans ce cas on ne fait rien */

  if((bord1->cnxe->sa==bord1->cnxe->sb)||(bord2->cnxe->sa==bord2->cnxe->sb))
           return;


 /** Si som se trouve entre deux comp. cnxes. de bords differents **/
 /*  C'est le cas standard                            */

  image.nbsommets--;               /* On enleve 'som' */
  image.nbbords--;     /* De deux bords on en fait un */

  /* Determination de l'ordre des deux bords a reunir */
  for (li=bord1->rg->Lbords;li->bord!=bord1;li=li->suiv) ;
  if (       ((li->suiv!=NULL) && (li->suiv->bord!=bord2)) 
        ||   ((li->suiv==NULL) && (bord2!=bord1->rg->Lbords->bord))   )
    {
         bord =bord1;       bord1=bord2;
         bord2=bord ;
    }


  /* Determination des comp. cnxes. de sommet 'som' et de leur orientation */
  /* avec:                                                                 */
  /*                                                              */
  /*         bcnxe1            som        bcnxe2         */
  /*     sb -------> sa (+1)   $     sb -------> sa (+1) */
  /*     sb -------> sa (+1)   $     sa <------- sb (-1) */
  /*     sa <------- sb (-1)   $     sb -------> sa (+1) */
  /*     sa <------- sb (-1)   $     sa <------- sb (-1) */
  /*                                                     */
  /*******************************************************/

  for(bcnxe=bord1->cnxe;bcnxe!=NULL;bcnxe=bcnxe->suiv) {
     if (bcnxe->sa==som) {bcnxe1=bcnxe;dir_bcnxe1=1;break;}
     if (bcnxe->sb==som) {bcnxe1=bcnxe;dir_bcnxe1=-1;break;}
  }

  for(bcnxe=bord2->cnxe;bcnxe!=NULL;bcnxe=bcnxe->suiv) {
     if (bcnxe->sa==som) {bcnxe2=bcnxe;dir_bcnxe2=-1;break;}
     if (bcnxe->sb==som) {bcnxe2=bcnxe;dir_bcnxe2=1;break;}
  }


 /* Mettre dans bord1 les deux bords: b1 <- b1+b2 */

  for (i=0;i<NC_BOR;i++) bord1->canal[i] += bord2->canal[i]   ;

  /* Est-ce qu'il faut changer l'orientation des bcnxes de bord2 */
  if (dir_bcnxe1!=dir_bcnxe2) 
      for(bcnxe=bord2->cnxe;bcnxe!=NULL;bcnxe=bcnxe->suiv) {
          sa_old=bcnxe->sa; bcnxe->sa=bcnxe->sb; bcnxe->sb=sa_old;
          lab_old=bcnxe->lab;bcnxe->lab=bcnxe->lba;bcnxe->lba=lab_old;
      }

  /* Repointer les sommets sur bord */
  for(bcnxe=bord2->cnxe;bcnxe!=NULL;bcnxe=bcnxe->suiv) {
    Repointer(bcnxe->sa,bord1,bord2);
    Repointer(bcnxe->sb,bord1,bord2);
  }

  /* Mettre les bcnxes ensembles dans bord1 */
  for(bcnxe=bord1->cnxe;bcnxe->suiv!=NULL;bcnxe=bcnxe->suiv) ;
  bcnxe->suiv=bord2->cnxe;

  /* Reunir les deux bcnxes dont som est un sommet dans bcnxe1 */
  if (dir_bcnxe1 == 1) {
         bcnxe1->sa=bcnxe2->sa;
         bcnxe1->lba=LiPixelsUnion(bcnxe1->lba,bcnxe2->lba);
         bcnxe1->lab=LiPixelsUnion(bcnxe2->lab,bcnxe1->lab);
  }
  else {
         bcnxe1->sb=bcnxe2->sb;
         bcnxe1->lba=LiPixelsUnion(bcnxe2->lba,bcnxe1->lba);
         bcnxe1->lab=LiPixelsUnion(bcnxe1->lab,bcnxe2->lab);
  }
  for(bcnxe=bord1->cnxe;bcnxe->suiv!=bcnxe2;bcnxe=bcnxe->suiv) ;
  bcnxe->suiv=bcnxe2->suiv;

  /* Elimination de bord2 des listes de bords des regions */
  ElimBordeReg(bord1->rg,bord2);
  ElimBordeReg(bord1->rd,bord2);
  subtract_heap(bord2);
}

void UnionBordCnxe(reg)  /* Reunit les bords de reg,qui font frontiere a une */
REGIONPTR reg;           /*  meme region voisine,                            */
{                        /*  on obtient le comp. connexes d'un bord          */
  short i,dir_bord2;
  static void Repointer();
  SOMMETPTR som;
  LI_PIXELSPTR lpix;
  LI_BORDSPTR lbor1,lbor2,lbor3,lbor;
  BORDPTR bord1,bord2;
  BORDCONNEXEPTR bcnxe;
  REGIONPTR reg1,reg2;
  
  lbor1=reg->Lbords;
  while((lbor1!=NULL)&&(lbor1->suiv!=NULL)) {
    bord1=lbor1->bord;
    reg1 = (bord1->rg==reg) ?  bord1->rd : bord1->rg ;
    lbor2=lbor1->suiv;
    do {
      bord2=lbor2->bord;
      reg2 = (bord2->rg==reg) ?  bord2->rd : bord2->rg ;
     /*Est-ce qu'il y a deux bords de reg,frontiere avec une meme autre region*/
      if (reg1==reg2) {
         image.nbbords--;                     /* De deux bords on en fait un */
         dir_bord2 = (bord1->rg==bord2->rg) ?  1 : -1 ;
         /* Les sommets des comp. cnxes. de bord2 doivent pointer vers bord1 */
         for(bcnxe=bord2->cnxe;bcnxe!=NULL;bcnxe=bcnxe->suiv) {
            Repointer(bcnxe->sa,bord1,bord2);
            Repointer(bcnxe->sb,bord1,bord2);
            if (dir_bord2==-1) {
               som=bcnxe->sa;bcnxe->sa=bcnxe->sb;bcnxe->sb=som;
               lpix=bcnxe->lab;bcnxe->lab=bcnxe->lba;bcnxe->lba=lpix;
            }  
         }
         /* Mettre les parties connexes dans bord1 */
         for(i=0;i<NC_BOR;i++) bord1->canal[i]+=bord2->canal[i];
	 subtract_heap(bord2);
         for(bcnxe=bord1->cnxe;bcnxe->suiv!=NULL;bcnxe=bcnxe->suiv) ;
         bcnxe->suiv=bord2->cnxe;

         /* Eliminer bord2 de la liste de bords de reg */
         for(lbor3=lbor1;lbor3->suiv->bord!=bord2;lbor3=lbor3->suiv) ;
         lbor=lbor3->suiv;
         lbor3->suiv=lbor->suiv;

         /* Eliminer bord2 de la liste de bords de reg1=reg2 */
         lbor3=reg1->Lbords;
         if (lbor3->bord==bord2) {
             lbor=lbor3;
             reg1->Lbords=lbor->suiv;
         }
         else {
             for( ;lbor3->suiv->bord!=bord2;lbor3=lbor3->suiv) ;
             lbor=lbor3->suiv;
             lbor3->suiv=lbor->suiv;
         }
         break;
      }
      else lbor2=lbor2->suiv;
    } while(lbor2!=NULL);
    lbor1=lbor1->suiv;
    update_heap(bord1);
  }    
}


void Repointer(som,newbord,oldbord) /* som va pointer sur newbord et plus sur*/
SOMMETPTR som;                      /*  oldbord,si'newbord'est deja dans la  */
BORDPTR newbord,oldbord;            /*  liste som->Lbords on elimine'oldbord'*/
{
  LI_BORDSPTR li;
  unsigned char existe_new;

  existe_new=FAUX;
  for(li=som->Lbords;li!=NULL;li=li->suiv) 
            existe_new |=(li->bord==newbord);
  if (existe_new==VRAI) {  /* On elimine 'oldbord' de la liste 'som->Lbords' */
       li=som->Lbords;
       if(li->bord==oldbord) 
         som->Lbords=li->suiv;
       else {
         for(li=som->Lbords;(li->suiv!=NULL)&&(li->suiv->bord!=oldbord);li=li->suiv) ;
         if(li->suiv==NULL) return;  /*'newbord existe deja et 'oldbord' plus */
         li->suiv=li->suiv->suiv;
       }
  }
  else  {               /* On fait pointer 'som' sur 'newbord' */
       for(li=som->Lbords;li->bord!=oldbord;li=li->suiv) ;
       li->bord=newbord;
  } 
}


void ElimBordeReg(reg,bord)                /* Elimination de bord dans la */
REGIONPTR reg;                             /*  liste de bords de region   */
BORDPTR bord;
{
  LI_BORDSPTR li;
 
  li=reg->Lbords;
  if (li->bord==bord)
     reg->Lbords=li->suiv;
  else {
     for ( ;li->suiv->bord!=bord;li=li->suiv) ;
         li->suiv=li->suiv->suiv;
     }
}



LI_PIXELSPTR 
LiPixelsUnion(liste1,liste2)                /* Met la liste de pixels liste2 */
LI_PIXELSPTR liste1,liste2;                 /*  derriere liste1              */
{
  LI_PIXELSPTR liste,lptr;

  for(liste=liste1;liste->suiv!=NULL;liste=liste->suiv);
  if (liste->direction==liste2->direction) {
    liste->longueur += liste2->longueur;
    lptr=liste2;
    liste->suiv=lptr->suiv;
  }
  else liste->suiv=liste2;

  return(liste1);
}


/* Procedure involving the functional */


float
eval_lambda(bord)  /* evaluate for which vakue of lambda this border will */
BORDPTR  bord;     /* vanish and its adjacent regions be merged           */
{
  REGIONPTR rg,rd;
  float u1_2,coef_aire,som_p=0.0,t_elastique;