Dégradé de couleurs

Le problème exposé dans ce sujet a été résolu.

Coucou !

J'ai réussi à faire les dégradés blanc noir et noir blanc, et le polychrome également ! Merci à tous pour votre aide et votre soutien, c'était vraiment cool de votre part !

Une petite question me taraude cependant :p En effet, on est partis de l'observation de dégradés existants déjà, et on a vu quelles relations liait la couleur à chaque abscisse grâce à ces dégradés déjà construits. On a vu que pour un dégradé monochrome noir-blanc par exemple, les trois composantes suivent une même fonction affine qui monte ; le dégradé polychrome, lui, est soumis à l'interpolation : ainsi chaque composante évolue selon sa propre fonction dont la définition dépend d'un intervalle (parfois il s'agit d'une fonction-constante, parfois d'une fonction affine).

Ma question est : pourquoi ? Pourquoi ça marche ? Pourquoi obtient-on un dégradé polychrome de cette manière ? J'imagine que ce n'est pas un hasard : est-ce une convention d'informaticiens ? Est-ce dû à la nature-même du système RGB ? On peut étendre cette question aux dégradés noir-blanc/blanc-noir : comment se fait-il que mettre une même fonction affine aux trois composantes donne un tel dégradé ?! Là non plus ce n'est pas dû au hasard…

EDIT :

Voici les images :p :

Et le source final :

 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
public void displayHorGraduation(String type) {
        double w = this.writable_image.getWidth();
        double r = 0, g = 0, b = 0;
        for(int x = 0; x < this.writable_image.getWidth(); x++) {
            for (int y = 0; y < this.writable_image.getHeight(); y++) {

                if(type.equals("Blanc vers noir")) {
                    this.writable_pixel_writer.setColor(x, y, Color.color(-x/w + 1, -x/w + 1, -x/w + 1));
                } else if(type.equals("Noir vers blanc")) {
                    this.writable_pixel_writer.setColor(x, y, Color.color(x/w, x/w, x/w));
                } else if(type.equals("Polychrome")) {

                    if(x >= 0 && x < w/6) {
                        r = 255;
                        g = 1530*x/w;
                    }

                    if(x >= 0 && x < 2*w/6) {
                        b = 0;
                    }

                    if(x >= 2*w/6 && x < 3*w/6) {
                        b = 1530*x/w - 510;
                    }

                    if(x >= 3*w/6 && x < 5*w/6) {
                        b = 255;
                    }

                    if(x >= 5*w/6 && x <= w) {
                        b = -1530*x/w + 1530;
                    }

                    if (x >= w/6 && x < 3*w/6) {
                        g = 255;
                    }

                    if(x >= 3*w/6 && x < 4*w/6) {
                        g = -1530*x/w + 1020;
                    }

                    if(x >= 4*w/6 && x <= w) {
                        g = 0;
                    }

                    if(x >= w/6 && x < 2*w/6) {
                        r = -1530*x/w + 510;
                    }

                    if(x >= 2*w/6 && x < 4*w/6) {
                        r = 0;
                    }

                    if(x >= 4*w/6 && x < 5*w/6) {
                        r = 1530*x/w - 1020;
                    }

                    if(x >= 5*w/6 && x <= w) {
                        r = 255;
                    }

                    this.writable_pixel_writer.setColor(x, y, Color.color(r/255, g/255, b/255));
                }
            }
        }
    }
+0 -0

Ma question est : pourquoi ? Pourquoi ça marche ? Pourquoi obtient-on un dégradé polychrome de cette manière ? J'imagine que ce n'est pas un hasard : est-ce une convention d'informaticiens ? Est-ce dû à la nature-même du système RGB ? On peut étendre cette question aux dégradés noir-blanc/blanc-noir : comment se fait-il que mettre une même fonction affine aux trois composantes donne un tel dégradé ?! Là non plus ce n'est pas dû au hasard…

Non ce n’est pas dû au hasard. Pour comprendre pourquoi ça marche, découpons comme dans mon précédent message l’image en six morceaux et analysons le premier morceau.

Sur le premier morceau, il n’y a jamais de bleu, le rouge vaut toujours 255 et le vert varie en augmentant. Cela veut dire qu’au départ on a que du rouge, et que plus on avance plus on rajoute du vert, or en mélangeant du rouge et du vert, on obtient du jaune, donc plus on avance plus on se rapproche du jaune. Quand on a fini, (quand le rouge et le vert ont pour valeur 255), on a du jaune.

Au début du deuxième morceau, on a alors du jaune. Sur tout le deuxième morceau, le bleu est à zéro, le vert est à 255, et le rouge diminue, donc plus on avance, plus on se rapproche du vert, jusqu’à n’obtenir que du vert quand le rouge atteint 0.

Et ainsi de suite.

+0 -0

D'accord, donc le premier informaticien qui a fait un tel dégradé savait ce qu'il voulait obtenir (d'abord du rouge, puis du jaune, etc.) et n'a fait que jouer avec RGB.

Dans ce cas voici la question qui me vient à l'esprit : le premier dégradé arc-en-ciel IRL (donc pas informatisé), comment a-t-il été fait ? Est-ce qu'on a choisi au hasard de commencer par du rouge, puis de mettre du jaune, etc. ?

+0 -0

Est-ce qu'on a choisi au hasard de commencer par du rouge, puis de mettre du jaune, etc. ?

Je ne pourrais pas du tout répondre à cette question, mais j’imagine que c’était justement pour reproduire le vrai arc-en-ciel (qui va de rouge à violet). En tout cas, j’ai déjà joué avec les dégradés pour voir ce qu’on pouvait obtenir et on obtient de belles choses en changeant quelques paramètres au hasard. :)

+0 -0

Le dégradé arc-en-ciel IRL est basé sur les longueurs d'onde de la lumière.

L'idée principale est que la lumière blanche1 du soleil est en fait composé de plein de lumières de longueurs d'onde différentes allant d'environ 400nm (violet) à 800nm (rouge). Une des propriétés de la lumière est que son indice de réfraction varie en fonction de sa longueur d'onde. C'est à dire que quand la lumière passe d'un milieu à un autre (air-eau ou air-verre par exemple), sa direction va changer et l'angle de ce changement varie en fonction de la longueur d'onde. C'est sur ça qu'est basé un prisme:

Décomposition de la lumière blanche par un prisme

Pour un arc-en-ciel, le principe est le même, à la différence prêt que ce sont les gouttelettes d'eau qui font office de prisme.

C'est donc l'ordre défini par la correspondance longueur d'onde -> couleur qui est naturellement utilisé pour faire un dégradé de couleur en informatique.

Maintenant, venons-en à l'explication de pourquoi est-ce qu'en mettant par exemple du rouge et du vert, on obtient du jaune. Pour cela, il faut voir comment fonctionne l'œil humain. La perception de la couleur se fait à l'aide de plusieurs types de photorécepteurs qui réagissent à différentes longueurs d'ondes. L'œil humain à habituellement 3 photorécepteurs2 qui sont sensibles à des longueurs d'ondes différentes représenté sur le schéma suivant:

Réponse des photorécepteurs de l'œil humain aux différentes longueurs d'ondes

Donc en réalité, l'œil ne perçoit pas une longueur d'onde précise, mais un certain niveau d'activation pour chaque type de capteur. Le cerveau s'occupe ensuite d'interpréter ces trois niveaux d'activation pour indiquer une couleur. Ce qui veux dire que quelque soit la composition réelle de la lumière reçu par l'œil, si le niveau d'activation des trois types de capteur est le même, le cerveau percevra la même couleur. Et c'est sur ça que joue RGB pour permettre d'avoir n'importe quel couleur, en n'ayant à disposition que 3 couleurs de base. En envoyant du rouge et du vert, on va simplement activer les photorécepteurs de l'œil de la même manière que le fait du jaune.

À ce niveau là, il ne me reste plus qu'à indiquer comment sont couramment fait les écrans pour finir la boucle3. En fait, chaque pixel d'un écran est composé de 3 LEDS: une rouge, une vert et une bleu. Je te laisse faire le lien avec système RGB habituellement utilisé.

  1. En réalité, elle n'est pas exactement blanche. Mais la simplification n'enlève rien à l'explication. ↩

  2. En excluant un certain nombre de maladies et les cas de quadrichromie. ↩

  3. Je décris ici la technologie la plus courante et au sein même de cette technologie, il y a aussi probablement un certain nombre de variations possibles. ↩

+3 -0

Une des propriétés de la lumière est que son indice de réfraction varie en fonction de sa longueur d'onde

EDIT : non, je me rends compte que je je racontais des bêtises. ^^

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte