one_levelset.c

image processing including fourier,wavelet,segmentation etc.

    }
  }
  printf(" finished !\n");
}

/* free all the 'callocated' memory blocks */
void
Image_free(imageptr)
MODELEPTR imageptr;
{
  free((void*)imageptr->b_data);
  free((void*)imageptr->b_reg);
  free((void*)imageptr->b_bor);
  free((void*)imageptr->b_som);
  free((void*)imageptr->b_borcnxe);
  free((void*)imageptr->b_libor1);
  free((void*)imageptr->b_libor2);
  free((void*)imageptr->b_lipix); 
}


/* Merging tools */

void RegMerge(reg,regvois,bordcom)/* On agglutine les regions reg et regvois */
REGIONPTR reg,regvois;            /* de bord commun bordcom,dans l'espace    */
BORDPTR bordcom;                  /* memoire de reg                          */
{
  unsigned short i;
  BORDCONNEXEPTR cnxeptr;
  static void LiBordsUnion(),ElimBordeSom(),DegreSommet(),ElimLiReg(),UnionBordCnxe();

  *reg->canal=MAX(*reg->canal,*regvois->canal);

  if (image.regpixel0_0==regvois)  image.regpixel0_0=reg;

  ElimLiReg(regvois);

  LiBordsUnion(reg,regvois,bordcom);

  ElimBordeSom(bordcom);

  image.nbregions--;image.nbbords--;

  for(cnxeptr=bordcom->cnxe;cnxeptr!=NULL;cnxeptr=cnxeptr->suiv) {
        DegreSommet(cnxeptr->sa);
        if (cnxeptr->sb != cnxeptr->sa) DegreSommet(cnxeptr->sb);
  }
  UnionBordCnxe(reg);
}


void ElimLiReg(regvois)             /* Elimine la region regvois de la liste */
REGIONPTR regvois;                  /* des regions,exit si deux regions      */
{                                   /* Utiliser avant LiBordsUnion()         */

  if (  ((regvois->Rprec==NULL)&&(regvois->Rsuiv->Rsuiv==NULL))  || 
        ((regvois->Rsuiv==NULL)&&(regvois->Rprec->Rprec==NULL))     ) {
    printf("\nThere is just one region which stays, no boundaries!\n");
    exit(0);
  }
  if (regvois->Rprec==NULL) {
    image.tete=regvois->Rsuiv;
    image.tete->Rprec=NULL;
  }
  else 
    if (regvois->Rsuiv==NULL)
      regvois->Rprec->Rsuiv=NULL;
    else {
      regvois->Rprec->Rsuiv=regvois->Rsuiv;
      regvois->Rsuiv->Rprec=regvois->Rprec;
    }
 }


void LiBordsUnion(reg,regvois,bordcom)/*  Fait l'union,suivant l'ordre de    */
REGIONPTR reg,regvois;        /*  parcours de la frontiere de reg+regvois,de */
BORDPTR  bordcom;             /*  la liste de bords de reg et regvois.       */
{                             /* En eliminant l'element pointant sur bordcom */
  LI_BORDSPTR li,L1,L2;

  /* Marquer bordcom dans la liste des bords de reg */
  if (reg->Lbords->bord==bordcom)   L1=reg->Lbords ;
  else     {
            for(li=reg->Lbords;li->suiv->bord!=bordcom;li=li->suiv);
            L1=li->suiv;
           }

  /* Les bords de regvois doivent pointer vers reg,marquer bordcom */
  for (li=regvois->Lbords;li!=NULL;li=li->suiv)
    {
      if (li->bord==bordcom) L2=li;
      if (li->bord->rg==regvois)  li->bord->rg=reg ; 
      else                        li->bord->rd=reg ;
    }

  /* Mise en place ,dans l'ordre, des bords de reg (sens de rot. +).*/
  /* Si  reg->Lbords = a-L1-b  et regvois->Lbords = c-L2-d  ,       */
  /*  alors le resultat est   reg->Lbords = a-d-c-b .               */
  if (reg->Lbords==L1)
     if (regvois->Lbords==L2)
         if (L1->suiv==NULL)
             if (L2->suiv==NULL) {      /*   L1-0    et   L2-0   ,li=0        */
                li=NULL;
             }
             else                {      /*   L1-0    et   L2-d   ,li=d        */
                li=L2->suiv;
             }
         else
             if (L2->suiv==NULL) {      /*   L1-b    et   L2-0   ,li=b        */
                li=L1->suiv;
             }
             else                {      /*   L1-b    et   L2-d   ,li=d-b      */
                for (li=L2;li->suiv!=NULL;li=li->suiv)    ;
                li->suiv=L1->suiv;
                li=L2->suiv;
             }
     else
         if (L1->suiv==NULL)
             if (L2->suiv==NULL) {      /*   L1-0    et   c-L2-0 ,li=c        */
                for (li=regvois->Lbords;li->suiv!=L2;li=li->suiv) ;
                li->suiv=NULL;
                li=regvois->Lbords;
             }
             else                {      /*   L1-0    et   c-L2-d ,li=d-c      */
                for (li=L2;li->suiv!=L2;li=li->suiv)
                     if (li->suiv==NULL) li->suiv=regvois->Lbords;
                li->suiv=NULL;
                li=L2->suiv;
             }
         else
             if (L2->suiv==NULL) {      /*   L1-b    et   c-L2-0 ,li=c-b      */
                for (li=regvois->Lbords;li->suiv!=L2;li=li->suiv) ;
                li->suiv=L1->suiv    ;
                li=regvois->Lbords;
             }
             else                {      /*   L1-b    et   c-L2-d  ,li=d-c-b   */
                for (li=L2;li->suiv!=L2;li=li->suiv)
                     if (li->suiv==NULL) li->suiv=regvois->Lbords;
                li->suiv=L1->suiv;
                li=L2->suiv;
             }
  else
     if (regvois->Lbords==L2)
         if (L1->suiv==NULL)
             if (L2->suiv==NULL) {      /*   a-L1-0  et   L2-0    ,li=a       */
                for (li=reg->Lbords;li->suiv!=L1;li=li->suiv)   ;
                li->suiv=NULL;
                li=reg->Lbords;
             }
             else                {      /*   a-L1-0  et   L2-d    ,li=a-d     */
                for (li=reg->Lbords;li->suiv!=L1;li=li->suiv);
                li->suiv=L2->suiv;
                li=reg->Lbords;
             }
         else
             if (L2->suiv==NULL) {      /*   a-L1-b  et   L2-0    ,li=a-b     */
                for (li=reg->Lbords;li->suiv!=L1;li=li->suiv) ;
                li->suiv=L1->suiv;
                li=reg->Lbords;
             }
             else                {      /*   a-L1-b  et   L2-d    ,li=a-d-b   */
                for (li=reg->Lbords;li->suiv!=NULL;li=li->suiv)  
                                      if (li->suiv==L1) li->suiv=L2->suiv;
                li->suiv=L1->suiv;
                li=reg->Lbords;
             }
     else
         if (L1->suiv==NULL)
             if (L2->suiv==NULL) {      /*   a-L1-0  et   c-L2-0  ,li=a-c     */
                for (li=reg->Lbords;li->suiv!=L2;li=li->suiv) 
                         if (li->suiv==L1) li->suiv=regvois->Lbords ;
                li->suiv=NULL;
                li=reg->Lbords;
             }
             else                {      /*   a-L1-0  et   c-L2-d  ,li=a-d-c   */
                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=NULL;
                li=reg->Lbords;
             }
         else
             if (L2->suiv==NULL) {      /*   a-L1-b  et   c-L2-0  ,li=a-c-b   */
                for (li=reg->Lbords;li->suiv!=L2;li=li->suiv) 
                         if (li->suiv==L1) li->suiv=regvois->Lbords   ;
                li->suiv=L1->suiv;
                li=reg->Lbords;
             }
             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 */