Discussion :

[shaiHulud]

Bonjour,

Je cherche à associer un code de couleurs à des entiers (par exemple 0-> bleu, 1-> vert, 2-> orange, 3-> rouge,...). Le but est donc de choisir N couleurs régulièrement espacées, disons entre le blanc et le noir (ou des couleurs froides vers les couleurs chaudes).

Il s'agit d'implémenter les palette Matlab, pour ceux qui connaissent (par exemple la fonction hsv()).

Connaissez vous un moyen simple de faire cela ? Je pense à paver régulièrement les valeurs hexadécimales, mais je ne sais pas comment respecter un ordre dans les couleurs (du froid vers le chaud).

Merci d'avance pour votre aide
Bonne après-midi

[pieral85]

Bonsoir,

j'avais implémenté un dégradé de couleurs dans un programme plus vaste. Ce dégradé fournit un code en hexadécimal du type #RRGGBB correspondant à une couleur (RR pour la valeur de la "teinte" rouge, GG pour la valeur de la "teinte" verte et BB pour la valeur de la "teinte" bleue).

Voilà un brouillon qui m'avait aidé pour trouver cette variation de couleurs (allant du bleu au rouge, en passant par le vert, le jaune puis l'orange).

Voilà aussi le code qui décrit cette variation (ne tenir que des lignes 134 à 152, à savoir la définition de la méthode var_coul(). Cette portion de code se base sur le graphique qui se comporte comme une fonction par partie divisée en 3 tiers.
Chacun de ces tiers contient les valeurs pour les 3 teintes (rouge, vert et bleu) qui sont en fait des équations de droites. De ce fait, le dégradé de couleur est très linéaire.

Code :

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
# -*- coding: cp1252 -*-
#---Compte à rebours---
 
from Tkinter import *
import threading
 
class CompteARebours(Tk):
 
    def __init__(self, duree=10):        
        Tk.__init__(self)   #Constructeur de la classe parente
        self.dureeIni = int(duree*60)
        self.title('Compte à rebours')#(Compte à rebours')
        self.coulBg='grey92'
        self.configure(bg=self.coulBg)
 
        self.f1 = Frame (self, bg=self.coulBg, width=200, height=85)
        self.f1.grid(padx=5, pady =5)
        self.f1.grid_propagate(0)
        self.f2 = Frame (self, bg=self.coulBg)#, width=300, height=50)
        self.f2.grid(padx=5, pady =5)
 
        self.boutStart = Button (self.f2, text='Démarrer', command=self.start)
        self.boutStart.grid(row=2, column=1, padx=5, pady=5)
        self.boutPause = Button (self.f2, width=8, command=self.pause)
        self.boutPause.grid(row=2, column=2, padx=5, pady=5)
        self.boutStop = Button (self.f2,text='Arrêter et réinitialiser'\
                                ,command=self.stop)
        self.boutStop.grid(row=2, column=3, padx=5, pady=5)
        self.texte = Label (self.f1, font=('Arial',40), bg=self.coulBg)
        self.texte.grid(padx=10, pady=10)
        self.init()
 
    def init(self):
        "(Ré)initialise les données"
        self.duree = self.dureeIni  #La durée du chrono se réinitialise
        self.ipause = False
        self.boutPause.configure(text='Pause')
        self.boutStart['state'],self.boutStop['state'],self.boutPause['state']=\
                'normal','disabled','disabled'
        self.coul = 'blue'
        self.affichage(self.coul)
        self.texte.configure(font=('Arial',40))
        self.dessine_sablier()
 
    def affichage(self, coul, hauteur=150, largeur=35):
        "Prépare l'affichage du chronomètre"
        affich = str(self.duree/60).zfill(2), ':', str(self.duree%60).zfill(2)
        self.texte.configure(text=affich, fg=coul)
 
    def variation(self):
        "Actualise le chronomètre avec la couleur correspondante"
        if not self.ipause and not self.istop:
            if self.duree/60==0:    #Dernière minute du chrono
                self.coul = 'red'
                self.affichage(self.coul)
                if self.duree==0:   #Lorsque le chrono atteint zéro
                    self.istop = True
                    self.boutPause['state']='disabled'                  
                    self.f3.delete(ALL)
                    self.after(5000, self.init)
            else:                   #Affichage "classique"
                self.coul = 'green'
                self.affichage(self.coul)
            self.dessine_sablier()
 
            if not self.istop:       #Recomence la boucle après 1 sec
                self.chrono = threading.Timer(1,self.variation)
                self.chrono.start()
                self.duree -= 1
 
    def start(self):
        "Démarre le chronomètre"
        self.istop = False
        self.boutStart['state'],self.boutStop['state'],\
                self.boutPause['state'] = 'disabled','normal','normal'
        self.variation()
 
    def pause(self):
        "Provoque une pause au chronomètre"
        self.ipause = not self.ipause
        if self.ipause:
            self.chrono.cancel()
            self.boutPause.configure(text='Reprendre')
            self.duree += 1
            self.coul = 'orange'
            self.affichage(self.coul)
            self.iclign = True
            self.dessine_sablier()
        else:            
            self.boutPause.configure(text='Pause')
            self.variation()
            self.iclign = False
        self.clignotement()
 
    def stop(self):
        "Remet le compteur à 0 puis réactualise"
        self.chrono.cancel()
        self.istop = True
        self.init()
 
    def clignotement(self):
        if self.ipause:
            self.clign = threading.Timer(0.7,self.clignotement)
            self.texte.configure(font=('Arial',40,'italic'))
            if self.iclign:
                self.affichage(self.coulBg)
            else:
                self.coul = 'orange'
                self.affichage(self.coul)
            self.iclign =not self.iclign
            self.clign.start()
        else:          
            self.texte.configure(font=('Arial',40)) #Essayer self.clign._Thread__stop()
            self.clign.cancel()
 
    def dessine_sablier (self, hauteur=150, largeur=35, varcoul=2):
        """Dessine un sablier sous forme d'un rectangle rétrécissant.
varcoul=0 ==> couleur uniforme du sablier,
varcoul=1 ==> couleurs identiques à celles du chronomètre,
varcoul=2 ==> dégradé de couleurs"""
        if varcoul==0:
            coulSab = 'blue'
        elif varcoul==1:
            coulSab = self.coul
        elif varcoul==2:
            coulSab = self.var_coul()
        self.f3 = Canvas (self, bg='grey80', width=largeur, height=hauteur)
        self.f3.grid(row=0, column=1, rowspan=2, padx=15, pady =10)
        h = hauteur - (self.duree / float(self.dureeIni) * hauteur)
        if self.duree!=0:
            self.f3.create_rectangle(0, h, largeur+1, hauteur+1,\
                                     fill=coulSab, outline=coulSab)
 
    def var_coul(self):
        "Fait varier la couleur du sablier en fct du temps restant"
        chronoInv = self.dureeIni - self.duree  #Valeur de l'abscisse
        delta = 255. / (self.dureeIni/3)    #Pente de la droite
        if chronoInv < self.dureeIni/3:     #1er tiers de l'équation
            R = 0   #Equation du type y = b + ax (pour la teinte rouge)
            G = delta * chronoInv   #Equation du type y = b + ax (pour le vert)
            B = 255 - delta * chronoInv#Equation du type y = b + ax (pour bleu)
        elif self.dureeIni/3 <= chronoInv < 2*self.dureeIni/3:  #2eme tiers
            R = delta * (chronoInv - self.dureeIni/3)
            G = 255
            B = 0
        elif 2*self.dureeIni/3 <= chronoInv <= self.dureeIni:   #3eme tiers
            R = 255
            G = 255 - delta * (chronoInv - 2*self.dureeIni/3)
            B = 0
        return '#' + hex(int(R))[2:].zfill(2) + hex(int(G))[2:].zfill(2)\
               + hex(int(B))[2:].zfill(2)   #Retourne un code hexadécimal...
                                            #...sous la forme #RRGGBB
if __name__ == "__main__":  #Si le module est exécuté en tant que programme...
    app = CompteARebours(1.30)#...et non en tant que bibliothèque de classes
    app.mainloop()

En espérant t'avoir plus aidé plus qu'embrouillé.

[shaiHulud]

Merci beaucoup Pieral85,

Ton code marche très bien. J'ai isolé la fonction et à peine retouché. Voici une implémentation de la palette hsv.

Code :

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
 
"""
Thanks to pieral85
"""
 
class struct:pass
 
def var_coul(N,num):
    """ Color Palette (Matlab hsv() like) from cold to hot
    num is integer: Returns the num-th color amongst N colors, 
    num is float in [0,1]: interpolates
    """
    if isinstance(num,float): num= int(num*N)
    assert isinstance(num,int)
    self= struct()
    duree=N            
    self.dureeIni = N#int(duree*60)
    self.duree= num    
    #chronoInv = self.dureeIni - self.duree  #Valeur de l'abscisse
    chronoInv = self.duree  #Valeur de l'abscisse
    delta = 255. / (self.dureeIni/3)    #Pente de la droite
    if chronoInv < self.dureeIni/3:     #1er tiers de l'equation
        R = 0   #Equation du type y = b + ax (pour la teinte rouge)
        G = delta * chronoInv   #Equation du type y = b + ax (pour le vert)
        B = 255 - delta * chronoInv#Equation du type y = b + ax (pour bleu)
    elif self.dureeIni/3 <= chronoInv < 2*self.dureeIni/3:  #2eme tiers
        R = delta * (chronoInv - self.dureeIni/3)
        G = 255
        B = 0
    elif 2*self.dureeIni/3 <= chronoInv <= self.dureeIni:   #3eme tiers
        R = 255
        G = 255 - delta * (chronoInv - 2*self.dureeIni/3)
        B = 0
    return '#' + hex(int(R))[2:].zfill(2) + hex(int(G))[2:].zfill(2)\
           + hex(int(B))[2:].zfill(2)
 
 
def palette(N):
    return lambda num:var_coul(N,num)
 
if __name__=="__main__":
    import Tkinter as tk
    root= tk.Tk()
    "you can make n vary to test different interpolations"
    n= 300
    for k in range(n): 
        "both arguments (int and float) work"       
        #c= var_coul(n,k) # WORKS
        c= var_coul(n,1.0/float(n)*float(k))
        l= tk.Label(text= str(k),background= c)
        print c
        l.grid(row= k%10 ,column=k/10)
    root.mainloop()

Ca me convient amplement, mais histoire de faire un post complet,
aurais-tu une idée pour générer les autres palettes matlab (couleurs espacées au maximum, couleur pastels, froides ou chaudes seulement, dégradé de gris etc) ?

[pieral85]

Pour générer d'autres variations de couleurs,

• j'utilise Google et choisis un dégradé qui me convient (voir image jointe).
• Ensuite à l'aide d'un logiciel de traitement d'image (personnelement, j'utilise PhotoFiltre), j'extrais le code hexadécimal de la couleur, à intervalles réguliers sur la "barre de variation".
• Après, je place ces points dans un graphique et trace les 3 droites/courbes correspondantes aux couleurs R, G et B (voir image de mon précédent message).
• Enfin j'essaie de transformer des 3 droites/courbes sous formes d'équations simples.

Cette méthode est assez longue à faire et il existe surement une manière plus "propre" pour obtenir un dégradé de couleurs. Cependant, il me permet d'obtenir le dégradé que je souhaite, tant que je possède une image représentant l'ensemble des variations de couleurs (http://www.google.fr/images?um=1&hl=...i=g10&aql=&oq= en propose plusieurs).

Je ne connais presque rien dans l'utilisation des couleurs, cependant je sais qu'on peut définir une couleur autrement que par son "code RGB": à l'aide du système TSL (teinte, saturation, luminosité): http://fr.wikipedia.org/wiki/Teinte_...n_lumi%C3%A8re
Cela pourra peut-être t'aiguiller pour obtenir des couleurs pastels, "froides" ou "chaudes".

Concernant ton code, j'ai quelques questions:

• Dans la ligne suivante, à quoi sert le mot-réservé "assert?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

assert isinstance(num,int)

(Quand on fournit à "assert" une valeur vraie, rien ne se passe tandis que quand on lui fournit une valeur fausse, une erreur est levée)...

• Par "palette matlab" et "palette hsv", que veux-tu dire exactement?

[shaiHulud]

Merci pour ta suggestion. Je peux effectivement prendre une image matlab représentant les palettes et tabuler les valeurs RGB (mm pas besoin d'extrapoler linéairement, une tabulation assez fine codée en dur peut suffire).

la ligne assert sert juste à verifier le type du second argument, et lèvera une exception si on lui fournit autre chose qu'un int ou float.

Habituellement j'utilise hsv pour avoir des couleurs ordonnées associées à des valeurs numériques (par exemple pour une matrice de corrélation, couleur chaude -> correl proches de 1, couleur froide -> correl proche de 0) mais les autres palettes donnent aussi des résultats jolis.

Les palettes permettent aussi de faire varier les couleurs des GUI en changeant juste la palette. Ci dessous les définitions des palettes matlab.

hsv
Hue-saturation-value color map.
hot
Black-red-yellow-white color map.
gray
Linear gray-scale color map.
bone
Gray-scale with tinge of blue color map.
copper
Linear copper-tone color map.
pink
Pastel shades of pink color map.
white
All white color map.
flag
Alternating red, white, blue, and black color map.
lines
Color map with the line colors.
colorcube
Enhanced color-cube color map.
jet
Variant of HSV.
prism
Prism color map.
cool
Shades of cyan and magenta color map.
autumn
Shades of red and yellow color map.
spring
Shades of magenta and yellow color map.
winter
Shades of blue and green color map.
summer
Shades of green and yellow color map.

[Jerome Briot]

Sous MATLAB, tu peux récupérer les valeurs RGB des couleurs contenues dans chaque palette en appelant la fonction correspondante et en spécifiant le nombre de couleurs à retourner.

Exemple pour la palette HSV :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
>> rgb = hsv(8)
 
rgb =
 
    1.0000         0         0
    1.0000    0.7500         0
    0.5000    1.0000         0
         0    1.0000    0.2500
         0    1.0000    1.0000
         0    0.2500    1.0000
    0.5000         0    1.0000
    1.0000         0    0.7500