1. #1
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut Programmer un effet de relief sur une image

    Bonjour.
    J'ai modifié une fonction déjà existante sur le net pour l'adapter à mon programme.
    Mon but était de donner du relief à une image.
    Voici la fonction en question :

    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
    image image_filter_rect_aux2 (image* I, int x1, int y1, int x2, int y2, int* K, int kCols, int kRows, int divisor)
    {
     
     int kCenterX = kCols / 2;
     int kCenterY = kRows / 2;
     int i, j, m, mm, n, nn, ii, jj;
     
     image J = image_create ((*I)->w, (*I)->h, 0xffffffff);
     
     
     for(j = y1 + 1 ; j < y2 - 1  ; j++)            
     {
        for(i = x1  + 1; i < x2 - 1 ; i++)         
        {
     
         byte r=0;
         byte g=0;
         byte b=0;
     
            for(m=0; m < kRows; m++)    
            {
                mm = kRows - 1 - m;      
     
                for(n=0; n < kCols; n++) 
                {
     
     
                    ii = i + (m - kCenterX);/*changer le i + et le j + en i - et en j - pour changer impression de relief*/
                    jj = j - (n - kCenterY);
                    if( ii >= 0 && ii < (*I)->w && jj >= 0 && jj < (*I)->h )
                     {
                       byte rr, gg, bb;
     
                       nn = kCols + 1 + n;
     
                       colour_get_rgb ((*I)->pixel [jj * (*I)->w + ii]  , &rr, &gg, &bb);  
     
                       r += (rr * (K[mm * kRows + nn])) / divisor ;
                       g += (gg * (K[mm * kRows + nn])) / divisor;
                       b += (bb * (K[mm * kRows + nn])) / divisor;
     
                       image_putpixel (J, i, j, make_colour(r, g, b, 0xff));
     
                     }   
                }
            }
        }
     }
     
    for (j = 0; j < J->h; j++)
     {
      for (i = 0; i < J->w; i++)
       {
        byte a, b, c;
        colour_get_rgb (J->pixel[j * J->w + i], &a, &b, &c);
        J->pixel[j * J->w + i] = make_colour (255-a, 255-b, 255-c, 0xff);
       }
     }
     
    /*
    for (j = 0; j < J->h; j++)
     {
      for (i = 0; i < J->w; i++)
       {
        byte a, b, c;
        colour_get_rgb (J->pixel[j * J->w + i], &a, &b, &c);
        if (J->pixel[j * J->w + i] == 0xffffffff)
         J->pixel[j * J->w + i] = make_colour (180, 180, 180, 0xff);
       }
     }
    */
     
     return J;
    }


    Quand je compare mon image (la première) à celle obtenue avec The Gimp (la seconde image), Je préfère le résultat obtenu avec The Gimp (ah bon? ça alors, c'est étonnant...)

    Voici ma question : Avec The Gimp, pour obtenir cet effet, on va dans Filtres => Distorsions => relief.

    Une fois là, on le choix de modifier : Azimut, Elevation, Profondeur. (il y a ausi le choix entre carte de relief et relief).

    Savez vous comment il serait possible de modifier la fonction que j'utilise pour paramétrer l'elevation, la profondeur et l'Azimut svp? ( + carte de relief et relief : quelle est la signification de tous ces termes?).

    De plus, quelle est la méthode pour "lisser" l'image et ne pas se retrouver, comme moi, avec des pixels tout pourris?

    Merci d'avance.

    image 1 (moi), image 2 (The Gimp )
    Images attachées Images attachées   

  2. #2
    Expert confirmé
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    juillet 2013
    Messages
    2 023
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : juillet 2013
    Messages : 2 023
    Points : 4 423
    Points
    4 423

    Par défaut

    Commence par t'amuser avec les matrices de convolution :

    Une petite mise en bouche:

  3. #3
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    Bonjour foetus.

    il y a un truc qui cloche dans ma fonctin, c'est sûr. Par exemple, quand j'applique la fonction (encore modifiée) suivante avec ce filtre et ces paramètres, j'obtiens l'image suivante. Ce qui n'est pas du tout le résultat attendu.

    Comment se débarrasser des pixels qui bruitent (c'est à dire ceux dont la couleur tranche trop avec la couleur de contexte de l'image)?

    Ne vaudrait il mieux pas passer par des coefficients à virgule, quitte à recalculer chaque pixel pour que la valeur de ceux ci s'approchent de la valeur au dessus / au dessous (par exemple 0.6 donne 1 et 0.4 donne 0)

    le résultat est le même avec une image 512 x 512 qu'avec une image 2200 x 1600




    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
    /*filtre*/
    int* laplacien[5*5] = {
      -1, -1, -1, -1, -1,
      -1, -1, -1, -1, -1,
     
      -1, -1, 24, -1, -1,
      -1, -1, -1, -1, -1,
      -1, -1, -1, -1, -1,  
    }; 
     
    /*Appel de la fonction*/
    image J = image_convolution (&I, 0, 0, 512, 512, &laplacien, 5, 5, 5, 7);
     
     
    /*Fonction elle même*/
     
    image image_convolution (image* I, int x1, int y1, int x2, int y2, int* K, int kCols, int kRows, int divisor, int luminosite)
    {
     
     int kCenterX = kCols / 2;
     int kCenterY = kRows / 2;
     int i, j, m, mm, n, nn, ii, jj;
     
    image J = image_create ((*I)->w, (*I)->h, 0xffffffff);
     
     
     
     
     for(j = y1 + kRows; j < y2 - kRows ; j++)            
     {
     
        for(i = x1 + kCols ; i < x2 - kCols; i++)         
        {
         byte r=0;
         byte g=0;
         byte b=0;
     
            for(m=0; m < kRows; m++)    
            {
                mm = kRows + 1 + m;      
     
                for(n=0; n < kCols; n++) 
                {
                    nn = kCols - 1 - n;
     
     
                    ii = i + (n + kCenterX);
                    jj = j + (n + kCenterY);
     
     
                    if( ii >= 0 && ii < (*I)->w && jj >= 0 && jj < (*I)->h )
                     {
                       byte rr, gg, bb;
     
                       colour_get_rgb ((*I)->pixel [jj * (*I)->w + ii], &rr, &gg, &bb);  
     
     
                       r += ((rr * (K[nn * kRows + mm])/divisor)+ luminosite) ;
     
                       g += ((gg * (K[nn * kRows + mm])/divisor) + luminosite) ;
     
                       b += ((bb * (K[nn * kRows + mm])/divisor) + luminosite) ;
     
     
                       image_putpixel_alpha(J->pixel + j * J->w + i , r, g, b, 0xff);
                     }   
     
                }
     
            }
     
        }
     
     }
     
     return J;
    }
    Images attachées Images attachées  

  4. #4
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    j'ai changé ma fonction (j'ai essayé de corriger sur papier avant d'écrire le code). J'ai modifié certaines opérations. Voici mon résultat. N'ayant aucune connaissance dans le domaine, pouvez vous me dire si l'image ci-dessous se rapproche du résultat normal avec ce filtre?

    qu'obtenez-vous avec ce filtre pour vos propres fonctions? sachant que l'image d'origine est en couleurs.

    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     int* laplacien[5*5] = {
      -1, -1, -1, -1, -1,
      -1, -1, -1, -1, -1,
     
      -1, -1, 24, -1, -1,
      -1, -1, -1, -1, -1,
      -1, -1, -1, -1, -1,  
    };
    Images attachées Images attachées  

  5. #5
    Membre actif
    Profil pro
    Inscrit en
    mai 2011
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mai 2011
    Messages : 147
    Points : 287
    Points
    287

    Par défaut Alternatives à un code existant

    Partir d'un code existant c'est à double-tranchant surtout que celui-ci est assez cryptique. I une image et i un int ? J une nouvelle image ? r et rr ? Pourquoi pas rrr ?! Après la logique derrière semble cohérente mais Je vois 3 alternatives :
    • Opter pour une bibliothèque de traitement d'images/calcul scientifique (Comme NumPy et SciPy en Python)
    • Jeter un coup d'œil au code de The GIMP puisque c'est un logiciel libre
    • Coder à partir d'explications/algorithmes afin de se les approprier

  6. #6
    Membre actif
    Profil pro
    Inscrit en
    mai 2011
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mai 2011
    Messages : 147
    Points : 287
    Points
    287

    Par défaut Progrès & pixels parasites

    Tu sembles te rapprocher de l'image de l'article Wikipédia. Pour les pixels parasites c'est peut-être parce qu'il faut borner les composantes. Si le calcul fait plus de 255 ou moins de 0 ça donne n'importe quoi. Désolé je peux pas être plus précis car je connais pas trop de filtre.

  7. #7
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    Je ne veux pas me servir d'une bibliothèque car je voudrais comprendre les rouages du truc.
    Pour mon niveau en maths, il est plutôt nul...

    I est un pointeur de struct nommée "image" dont les champs sont "int w (width), int h (height) et colour* pixel (colour* étant un pointeur d'unsigned char). J'ai repris cette struct des cours de Jacques Olivier Lapeyre, sur youtube.

    J'avais réussi à régler une fonction avec une effet de relief trés réussi, mais j'ai mis le code à la corbeille par inadvertance. Je vais essayer de le retrouver.

  8. #8
    Membre actif
    Profil pro
    Inscrit en
    mai 2011
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mai 2011
    Messages : 147
    Points : 287
    Points
    287

    Par défaut Intérêt des biblios, Lapeyre vs. Developpez.com & gestion des versions

    Pour les biblios justement te servir d'une peut être une première étape pour comprendre. Après rien ne t'empêche de te plonger dans son code et faire la même chose à ta sauce. L'intérêt c'est que ça soit documenté, plus fiable… Elles sont aussi souvent accompagnées de plein de ressources dont des pédagogiques justement pour permettre à tout le monde de les utiliser. Sinon personne n'est nul en math on passe tous par la même case départ. D'ailleurs les problèmes que t'as résolu prouve que t'es capable de plein de choses !

    Alors j'ai jeté un coup d'œil aux cours de Lapeyre et c'est un professeur très productif mais peut-être justement que c'est au détriment de la qualité. Certes il y a plusieurs façons de faire mais c'est important d'adapter des explications ou un code. Comment est-ce que tu appelerais une variable de type image ? Comment parcourerais-tu les pixels d'une image ? Aussi en utilisant i et j ? La première fois que j'étais tombé sur ce code, dans l'autre discu je crois, je me souviens aussi que j'avais tilté sur les pointeurs. Des trucs comme (*I)->w c'est compliquer les choses pour rien et quand on débute c'est encore pire. Mon C est rouillé mais ça veut dire qu'I est un pointeur de pointeur d'où l'* devant ! Si les & viennent aussi de toi je te conseille de réviser cette spécificité du langage car c'est vrai qu'on peut s'y perdre au début ou si on tombe sur des trucs un peu tordus. On en revient encore aux bases vraiment importantes pour avancer sans stresser. Au passage tu as jeté un coup d'œil aux ressources du site ? Question de comparer avec celles de Lapeyre. Je me souviens que les FAQs C/C++ m'avaient été utiles il y a quelques mois pour vérifier quelques trucs…

    Enfin pour ton code perdu pour que ça n'arrive plus une solution miracle c'est un logiciel de gestion des versions (CVS, Subversion…). Ça change réellement la vie d'un développeur ! Ça t'aurait permis d'archiver une version de ton projet avec un fier commentaire pour bien marquer l'évènement. Une astuce temporaire pourrait consister à nommer différemment plusieurs fonctions similaires et donc à conserver toutes celles le méritant.

  9. #9
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    Merci encore pour les encouragements et les conseils.
    J'en profite pour poster des images obtenues avec une fonction encore modifiée, qui prend en compte la transparence des pixels de l'image de destination.
    Le résultat est presque satisfaisant :

    Les images couleur sont les images source, et les images en noir et blanc sont celles traitées. Elles sont en noir et blanc (ou plutôt niveaux de gris) car j'ai repassé les images traitées dans une fonction qui transforme une image couleur en une image en niveaux de gris.

    (le cercle et la ligne qu'on voit que l'image niveaux de gris des lions est une image de test, pour suivre les conseils de ternel, que j'ai oublié d'enlever)
    Images attachées Images attachées     

  10. #10
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    la même fonction avec un coefficient négatif un filtre différent (edge):

    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    int* edge[3 * 3] = {/*Plus on augmente le diviseur dans le négatif, plus le contraste est elevé*/
     (int*)1, (int*)1, (int*)1,
     (int*)1, (int*)-4,(int*) 1,
     (int*)1, (int*)1, (int*)1
    };
     
    image J = image_convolution (&I, 0, 0, I->w, I->h, &edge, 3, 3, -64);
    Images attachées Images attachées   

  11. #11
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut WO P***** J'AI REUSSI!!!



    Salut!

    J'ai enfin réussi à obtenir ce que je voulais exactement!

    J'ai refait entièrement la fonction, et ce qui m'a fait comprendre comment marche la convolution d'image, c'est ce site :

    http://setosa.io/ev/image-kernels/

    Bon, ok, je dois être le millionième à écrire ma fonction, mais cette fois ci, c'est de moi. Quel pied!

    Voici le code :

    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
    image image_convolution_labo (image* I, int x1, int y1, int x2, int y2, int* K, int kCols, int kRows, int divisor, int coef)
    {
     int i, j, m, n;
     colour c;
     image J;
     byte rr, gg, bb,aa;
     byte r, g, b, a;
     J = image_create ((*I)->w, (*I)->h, 0xffffffff);
     
     for(j = y1 ; j < y2   ; j++)            
      {
       for(i = x1  ; i < x2  ; i++)         
        {
         r = 0; g = 0; b = 0; a = 0;
           for(m=0; m < kRows; m++)    
            {
                int index_Image = 0;
                int index = 0;
                for(n=0; n < kCols; n++) 
                 {
                    index = m * kRows +  n;
                    index_Image = (m +j) * (*I)->w + n + i;
                    colour_get_rgba ((*I)->pixel [index_Image]  , &rr, &gg, &bb, &aa);  
     
                    if (r >= 0 && r < 256 && g >= 0 && g < 256 && b >= 0 && b < 256)
                      {
                       r += ((rr * (K[index])) / divisor) + coef;
                       g += ((gg * (K[index])) / divisor) + coef;
                       b += ((bb * (K[index])) / divisor) + coef;
                       a += ((aa * (K[index])) / divisor) + coef;
                       normalise_bytes (&r, &g, &b);
                       c = make_colour (r, g, b, 0xff);
                       image_putpixel(J, i, j, c);
                       index++;
                      }
                 }     
            }   
        } 
     }    
     
     
     return J;
    }

    Voici l'image de départ :
    Images attachées Images attachées  

  12. #12
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut Et voici les images transformées :

    1/2
    Images attachées Images attachées   

  13. #13
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    2/2
    Images attachées Images attachées   

  14. #14
    Rédacteur/Modérateur


    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2011
    Messages
    6 625
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : août 2011
    Messages : 6 625
    Points : 13 937
    Points
    13 937
    Ma page sur developpez.com : http://chrtophe.developpez.com/ (avec mes articles)
    Mon article sur la création d'un système : http://chrtophe.developpez.com/tutoriels/minisysteme/
    Mon article sur le P2V : http://chrtophe.developpez.com/tutoriels/p2v/
    Consultez nos FAQ : Windows, Linux, Virtualisation

  15. #15
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    merci pour le lien, j'avais déjà lu l'article, mais mon niveau en maths ne me permet même pas de traduire les formules du type :

    Nom : latex-id3.png
Affichages : 56
Taille : 2,1 Ko

    Nom : latex-id12.png
Affichages : 57
Taille : 1,5 Ko


    Je vais tout de même exposer ce que je comprends, par exemple à la page 5 de l'article:

    - on suppose qu'on décompose le pixel à traiter en ses composantes r, g, b.

    - on calcule les facteurs positifs et négatifs de la matrice: par exemple pour une matrice
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    int* K {-1, 0, 1,
              -1, 0, 1
              -1, 0, 1};


    le facteur négatif est -3; le facteur positif est +3, et donc la valeur la plus grande entre la valeur absolue de -3 est la valeur absolue de +3, c'est +3. Donc, le facteur de normalisation est : +3.

    - Ce facteur (+3), est ce avec quoi on va diviser chaque composante r, g, b;

    => Doit on diviser TOUTES les composantes r, g, b, ou SEULEMENT les composantes r, g,b qui dépassent la valeur 255?
    => que fait on des composantes r, g, b négatives? Doit on aussi les diviser ou bien doit on les remettre à 0?

    L'article dit "si la valeur obtenue n'est pas dans les limites imposées par le format (entier(s) entre 0...255), alors la valeur doit être normalisée". => "SI la valeur obtenue...ALORS elle doit être normalisée".

  16. #16
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut Sobel réussi, mais orientation du gradient non comprise.

    Bon, j'ai réussi mes filtres de Sobel, grâce à la chaîne youtube COMPUTERPHILE.

    En revanche, je ne comprends pas comment implémenter l'orientation du gradient, avec la fonction atan.

    Qqu'1 pour m'expliquer ce dernier point svp?

    Mes images :
    Images attachées Images attachées      

  17. #17
    Membre actif
    Profil pro
    Inscrit en
    mai 2011
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mai 2011
    Messages : 147
    Points : 287
    Points
    287

    Par défaut Orientation

    Qui dit orientation dit angle et atan te permet de le calculer à partir du couple sinus/cosinus (y/x) dans un triangle rectangle par exemple. C'est de la trigonométrie et d'après l'article Wikipédia sur le filtre de Sobel il faut t'aider de 2 matrices (horizontal/vertical).

    Sinon super pour tes progrès !

  18. #18
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    ok pour D(x,y) = Arctan(Gy/Gx).

    Mais une fois qu'on a déterminé cela, qu'est-ce qu'on en fait? Mon but est de colorer les contours avec les couleurs du cercle chromatique, c'est à dire que les contours blancs deviennent multicolores.

  19. #19
    Membre actif
    Profil pro
    Inscrit en
    mai 2011
    Messages
    147
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mai 2011
    Messages : 147
    Points : 287
    Points
    287

    Par défaut Angles et couleurs

    Je comprends à peu près ce que tu veux faire. Est-ce que tu as un résultat pour te guider ? Sinon c'est important de comprendre à quoi sert l'angle calculé. Par exemple à quoi correspond le blanc ? À partir de là juste en scannant l'article Wikipédia le coloriage me semble logique. Mais attention je rappelle que je ne connais pas suffisamment ce filtre ! Je me base juste sur d'autres problèmes résolus.

  20. #20
    Membre régulier
    Homme Profil pro
    autre
    Inscrit en
    juillet 2015
    Messages
    103
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : autre

    Informations forums :
    Inscription : juillet 2015
    Messages : 103
    Points : 86
    Points
    86

    Par défaut

    Voilà le résultat que j'aimerais obtenir.
    Il me semble que le blanc correspond à un angle de 0°. Mais comment obtenir un autre résultat que blanc, avec des contour plus fins, presque translucides, et colorés? pour l'instant, mystère...
    (l'image est volontairement grosse pour qu'on puisse distinguer la finesse des contours obtenue avec The Gimp).
    Images attachées Images attachées  

Discussions similaires

  1. Comment réaliser cet effet de texte sur une image ?
    Par creale10 dans le forum jQuery
    Réponses: 4
    Dernier message: 25/07/2012, 13h28
  2. Effet de couleur sur une image
    Par icesiiik dans le forum JavaFX
    Réponses: 1
    Dernier message: 26/04/2011, 01h42
  3. [Article] Appliquer un effet de zoom sur une image avec les CSS
    Par Bovino dans le forum Publications (X)HTML et CSS
    Réponses: 1
    Dernier message: 17/10/2010, 07h53
  4. Appliquer un effet de zoom sur une image avec les CSS
    Par Kerod dans le forum Mise en page CSS
    Réponses: 1
    Dernier message: 17/10/2010, 07h53
  5. problème avec un rollover (effet de survol) sur une image/bouton
    Par f56bre dans le forum Mise en page CSS
    Réponses: 2
    Dernier message: 19/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