IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

algorithme de remplissage en 4 connexité (lent) -> image non remplie complètement


Sujet :

C

Mode arborescent

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé

    Homme Profil pro
    autre
    Inscrit en
    Juillet 2015
    Messages
    176
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : Juillet 2015
    Messages : 176
    Par défaut algorithme de remplissage en 4 connexité (lent) -> image non remplie complètement
    Bonjour,
    j'ai écrit une fonction de remplissage en 4 connexité, mais le résultat n'est pas "plein". Il y a beaucoup de pixels oubliés. Cela vient-il du fait qu'il s'agit d'une '4-connexité' et non d'un '8-connexité'?

    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    void flood_fill (image I, int x, int y, colour couleur_de_remplissage)
    {
     int position_P1 = image_offset (I, x, y);
     
     fifo F = standard_empty_fifo_create (NULL, NULL, NULL, NULL);
     fifo_push (F, (void*) position_P1);
     
     
     int position_P_nord = 0;
     int position_P_sud = 0;
     int position_P_est = 0;
     int position_P_ouest = 0;
     
     int position_P_diagonale_haut_gauche = 0;
     int position_P_diagonale_bas_gauche = 0;
     int position_P_diagonale_haut_droite = 0;
     int position_P_diagonale_bas_droite = 0;  
     
     
     while (!is_fifo_empty (F))
      {
        /* 
       assert (position_P1 >= 0);
       assert (position_P_nord >= 0);
       assert (position_P_sud < I->h);
       assert (position_P_est < I->w);
       assert (position_P_ouest >= 0);
       */
     
       if (position_P_sud > I->h) position_P_sud = I->h - 1;
       if (position_P_nord < 0) position_P_nord = 0;
       if (position_P_est < 0) position_P_est = 0;
       if (position_P_ouest > I->w) position_P_ouest = I->w -1;
     
     
       position_P1 = (int) fifo_pop (F);   
     
     
     
     
       /*if ((I->pixel[position_P1] != c) && (I->pixel[position_P1] == 0x000000FF)) return;*/
       /*if (I->pixel[position_P1] == 0x000000FF) return;*/
       if (I->pixel[position_P1] != couleur_de_remplissage) I->pixel[position_P1] = couleur_de_remplissage;
     
     
       position_P_nord = position_P1 - I->w;
       position_P_sud = position_P1 + I->w;
       position_P_est = position_P1 + 1;
       position_P_ouest = position_P1 - 1;
     
       position_P_diagonale_haut_gauche = position_P_nord - 1;
       position_P_diagonale_bas_gauche = position_P_sud - 1;
       position_P_diagonale_haut_droite = position_P_nord + 1;
       position_P_diagonale_bas_droite = position_P_nord + 1;  
     
    /*
       if (position_P_diagonale_haut_gauche < 0) position_P_diagonale_haut_gauche = 0;
     
       if (position_P_diagonale_haut_droite > I->w) position_P_diagonale_haut_droite = I->w - 1;
       if (position_P_diagonale_haut_droite < 0) position_P_diagonale_haut_droite = 0;   
     
       if (position_P_diagonale_bas_droite > I->w) position_P_diagonale_haut_droite = I->w - 1;
       if (position_P_diagonale_bas_droite > I->h) position_P_diagonale_bas_droite = I->h - 1;   
     
       if (position_P_diagonale_bas_gauche < 0) position_P_diagonale_bas_gauche = 0;
       if (position_P_diagonale_bas_gauche > I->h) position_P_diagonale_bas_gauche = I->h -1;   
     
    */
     
       if ((I->pixel[position_P_nord] != couleur_de_remplissage) && (I->pixel[position_P_nord] != 0x000000FF)) 
         fifo_push (F, (void*) position_P_nord);
     
       if ((I->pixel[position_P_sud] != couleur_de_remplissage) && (I->pixel[position_P_sud] != 0x000000FF)) 
         fifo_push (F, (void*) position_P_sud);
     
       if ((I->pixel[position_P_est] != couleur_de_remplissage) && (I->pixel[position_P_est] != 0x000000FF)) 
         fifo_push (F, (void*) position_P_est);
     
       if ((I->pixel[position_P_ouest] != couleur_de_remplissage) && (I->pixel[position_P_ouest] != 0x000000FF)) 
         fifo_push (F, (void*) position_P_ouest);
     
     
    /*        
        if ((I->pixel[position_P_diagonale_haut_gauche] != couleur_de_remplissage) && (I->pixel[position_P_diagonale_haut_gauche] != 0x000000FF)) fifo_push (F, (void*) position_P_diagonale_haut_gauche);
     
       if ((I->pixel[position_P_diagonale_haut_droite] != couleur_de_remplissage) && (I->pixel[position_P_diagonale_haut_droite] != 0x000000FF)) fifo_push (F, (void*) position_P_diagonale_haut_droite);
     
     
       if ((I->pixel[position_P_diagonale_bas_gauche] != couleur_de_remplissage) && (I->pixel[position_P_diagonale_bas_gauche] != 0x000000FF)) fifo_push (F, (void*) position_P_diagonale_bas_gauche);
      
       if ((I->pixel[position_P_diagonale_bas_droite] != couleur_de_remplissage) && (I->pixel[position_P_diagonale_bas_droite] != 0x000000FF)) fifo_push (F, (void*) position_P_diagonale_bas_droite);
          
            
      */      
     
     
     
     
     
       fifo_remove(F);
     
      }
     
     fifo_destroy(&F);
     
    }
    Images attachées Images attachées  

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. algorithme de remplissage
    Par Aquaa dans le forum Algorithmes et structures de données
    Réponses: 0
    Dernier message: 02/02/2010, 09h40
  2. Algorithmes de remplissage (≠ flood fill)
    Par Luke58 dans le forum Traitement d'images
    Réponses: 1
    Dernier message: 24/11/2009, 16h40
  3. Algorithme de remplissage d'une matrice
    Par bettiboo94 dans le forum MATLAB
    Réponses: 1
    Dernier message: 18/05/2008, 05h53
  4. Algorithme de remplissage d'un triangle
    Par nicolas66 dans le forum Développement 2D, 3D et Jeux
    Réponses: 3
    Dernier message: 15/05/2007, 10h00
  5. [XSLT] algorithme de remplissage d'armoire
    Par tylenchus dans le forum XSL/XSLT/XPATH
    Réponses: 2
    Dernier message: 03/03/2007, 14h10

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo