[ASP.NET/C#] Algorithme Colorimétrique

**oxa** · 14/01/2008, 19h24

Bonjour,
je suis entrain de coder un outil permettant de modifier la teinte d'une image sans pour autant modifier les tons.

Je veux par exemple partir d'une image bleu clair pour arriver à une image rouge clair.

Je cherche un algorithme me permettant de transformer ces valeurs à la volée.

J'ai tenté de faire un ratio RVB pour aller du bleu au rouge mais je n'ai pas l'impression que ce soit une science exact puisque je me retrouve avec des valeurs R,V ou B dépassant les 255 en sortie

Quelqu'une pourrait-il m'aider s'il vous plait?

Merci,
Oxa

**ZaaN** · 15/01/2008, 12h39

Travaille en HSL à la place de RGB !

Tu pourra faire varier facilement la teinte de ton image.

**oxa** · 15/01/2008, 13h00

Merci pour ta réponse

J'ai trouvé ca aussi sur wikipedia
http://fr.wikipedia.org/wiki/Codage_...s#RVB_vers_TSL

J'essai maintenant de traduire le code en C# mais les résultats ne sont pas probants

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
float luminosite = c.GetBrightness()*100;
                        float teinte = c.GetHue();
                        float saturation = c.GetSaturation() * 100;
 
                        float tMax = 240;
                        float lMax = 240;
                        float sMax = 240;
                        float VMax = 255;
 
                        float M = 0;
                        float m = 0;
                        float delta = 0;
 
                        float R = 0;
                        float G = 0;
                        float B = 0;
 
                        float t0 = ((6 * teinte) / tMax);
 
                        if (luminosite <= (lMax / 2))
                        {
                            M = VMax * (luminosite / lMax) * (1 + (saturation / sMax));
                            m = VMax * (luminosite / lMax) * (1 - (saturation / sMax));
                        }
                        else
                        {
                            M = VMax * (((luminosite / lMax) * (1 - (saturation / sMax))) + (saturation / sMax));
                            m = VMax * (((luminosite / lMax) * (1 + (saturation / sMax))) - (saturation / sMax));
                        }
 
                        delta = M - m;
 
                        int i = (Int16)t0;
                        switch (i)
                        {
                            case 0:
                                R = R;
                                G = m + (t0 * delta);
                                B = m;
                                break;
                            case 1:
                                R = m + ((2 - t0) * delta);
                                G = M;
                                B = m;
                                break;
                            case 2:
                                R = m;
                                G = M;
                                B = m + ((t0 - 2) * delta);
                                break;
                            case 3:
                                R = m;
                                G = m + ((4 - t0) * delta);
                                B = M;
                                break;
                            case 4:
                                R = m + ((t0 - 4) * delta); ;
                                G = m;
                                B = M;
                                break;
                            case 5:
                                R = M;
                                G = m;
                                B = m + ((6 - t0) * delta);
                                break;
                        }
                        Color color = Color.FromArgb((Int16)R, (Int16)G, (Int16)B);

La luminosité et la saturation sont erronées et me donnent des valeurs proches de 0