Dégradé de couleur en RGB [Résolu]

Question

Posez votre question Signaler

Dégradé de couleur en RGB [Résolu]

moumouteb

Messages postés: 192
Date d'inscription: dimanche 16 janvier 2005
Dernière intervention: 28 février 2011

- 31 mars 2008 à 17:34 - Dernière réponse : VelocityPulse - 8 févr. 2016 à 13:21

C++ & C++ .NET Posez votre question Signaler

Bonjour.

Voila pour représenter des températures je dois dans un programme je dois faire un dégradé de couleurs du jaune au rouge. Il faut donc que je fasse ça avec les RGB. Comment faire pour obtenir un dégradé uniforme avec n couleurs différentes?

Je demande pas l'algorithme tout fait (bien que je ne sois pas contre) mais au moins le principe :" tu ajoutes deux au rouge et trois au vert" enfin quelque chose comme ça que je puisse ensuite généraliser dans un algorithme.

Donc voila si quelqu'un peut me donner la méthode de création d'un dégradé merci bien.

Quand la merde vaudra de l'or les pauvres naitront sans trou du cul. Coluche.

Afficher la suite

A voir également:

Votre réponse

Répondre au sujet

20/24 réponses

Votre réponse

Répondre au sujet

Posez votre question

1 2 Suivant

Pistol_Pete · Answer 1 · 2008-03-31T17:58:12+0200

Signaler Commenter la réponse de Pistol_Pete

Pistol_Pete

Messages postés: 1055
Date d'inscription: samedi 2 octobre 2004
Dernière intervention: 9 juillet 2013

31 mars 2008 à 17:58

0

Merci

Salut

Il faut que tu convertisses tes couleurs en HSL (Hue saturation Luminance) Ainsi en ne modifiant qu'un unique parametre, Hue, tu auras ton jolie degrader.
Il faut donc que tu codes la convertion du HSL en RGB, (C'est pas tres difficile)

A+

cs_laurent1024 · Answer 2 · 2008-03-31T18:05:47+0200

Signaler Commenter la réponse de cs_laurent1024

cs_laurent1024

Messages postés: 987
Date d'inscription: mardi 31 mai 2005
Dernière intervention: 30 août 2012

31 mars 2008 à 18:05

0

Merci

Cela doit pouvoir aussi marcher :
Rouge = [255, 0, 0]
jaune = [255, 165, 0] (d'apres http://fr.wikipedia.org/wiki/Orange_(couleur))
n = nombre de couleur intermédiaire
0 <= x <= n
Couleur intermédiaire x = [255, x * 165/n, 0]

Cdt

vecchio56 · Answer 3 · 2008-03-31T19:23:28+0200

Signaler Commenter la réponse de vecchio56

vecchio56

Messages postés: 6539
Date d'inscription: lundi 16 décembre 2002
Dernière intervention: 22 août 2010

31 mars 2008 à 19:23

0

Merci

D'accord avec laurent, pourquoi passer par HSL?

_____________________________________

Miquel75 · Answer 4 · 2008-03-31T19:33:07+0200

Signaler Commenter la réponse de Miquel75

Miquel75

Messages postés: 41
Date d'inscription: mercredi 5 mars 2008
Dernière intervention: 23 avril 2009

31 mars 2008 à 19:33

0

Merci

> Il faut que tu convertisses tes couleurs en HSL

Pas de rapport.
Les gradients se sont toujours faits en bouclant sur RGB

moumouteb · Answer 5 · 2008-03-31T19:40:24+0200

Pour avoir tester la méthode de Laurent je suis ok.
A la seule condition de remplacer jaune par jaune=[255,255,0] (le lien qui ait mis est celui du orange ^^).
Enfin la technique marche très bien ici (et me suffit j'en demande pas plus) mais c'est vrai que si le degradé devait se faire entre d'autres couleurs ça deviendrait peut être un peu plus problèmatique (si il faut jouer sur plusieurs couleurs en même temps).

Mais pour ma part ça me va très bien merci.

<hr width="100%" size="2" />
Quand la merde vaudra de l'or les pauvres naitront sans trou du cul. Coluche.

Pistol_Pete · Answer 6 · 2008-03-31T20:34:39+0200

Signaler Commenter la réponse de Pistol_Pete

Pistol_Pete

Messages postés: 1055
Date d'inscription: samedi 2 octobre 2004
Dernière intervention: 9 juillet 2013

31 mars 2008 à 20:34

0

Merci

Salut Vecchio

Pourquoi passer par HSL? Essaie simplement de faire un dégrader du rouge au violet en RGB et tu comprendras. (Regardes la boite de dialogue "couleurs personnalisées" avec Paint c'est plus parlant.)

Miquel75 >>je pense que tu parles trop vite. J'ai toujours fais mes dégrader en HSL et c'est pas près de changer.

A+

vecchio56 · Answer 7 · 2008-03-31T20:39:36+0200

Signaler Commenter la réponse de vecchio56

vecchio56

Messages postés: 6539
Date d'inscription: lundi 16 décembre 2002
Dernière intervention: 22 août 2010

31 mars 2008 à 20:39

0

Merci

Je fais toujours mes dégradés en RGB, et ca n'a rien de sorcier
Et je ne comprends pas pourquoi avec ta méthode on ne joue que sur le paramètre Hue

_____________________________________

Pistol_Pete · Answer 8 · 2008-03-31T21:32:07+0200

J'aimerai bien voir ta méthode pour faire de large dégrader. Du rouge au violet par exemple.
Moi je ne change que la teinte (Hue) la saturation et l'éclairement reste constant. Je n'ai donc qu'un unique paramètre sur lequel je boucle.
En RVB Rouge (206,0,0) <-------------> Vert(20,206,0)<---------->Violet(206,0,206)
En HSL Rouge(0,240,97)<-------------> Vert(76,240,97)<---------->Violet(200,240,97)

C'est flagrant.

D'ailleurs ce n'es pas par hasard que Paint utilise HSL pour générer sont dégrader:
En abscisse la teinte, en ordonnée la saturation et en z la luminance.
Je trouve que cet espace de couleur est très instinctif et devrait être plus utilisé.C'est bien plus facile de segmenter des images couleurs dans cet espace.

A+

vecchio56 · Answer 9 · 2008-03-31T21:45:43+0200

Signaler Commenter la réponse de vecchio56

vecchio56

Messages postés: 6539
Date d'inscription: lundi 16 décembre 2002
Dernière intervention: 22 août 2010

31 mars 2008 à 21:45

0

Merci

Mais en HSL, tu ne peux pas faire de dégradé entre 2 couleurs quelconques...

_____________________________________

Pistol_Pete · Answer 10 · 2008-03-31T22:11:41+0200

Signaler Commenter la réponse de Pistol_Pete

Pistol_Pete

Messages postés: 1055
Date d'inscription: samedi 2 octobre 2004
Dernière intervention: 9 juillet 2013

31 mars 2008 à 22:11

0

Merci

Il faut que les couleurs aient la même saturation et la même luminance pour faire facilement un dégrader. Après il faut feinter comme en RGB.

A+

luhtor · Answer 11 · 2008-03-31T22:45:44+0200

Signaler Commenter la réponse de luhtor

luhtor

Messages postés: 2023
Date d'inscription: mardi 24 septembre 2002
Dernière intervention: 28 juillet 2008

31 mars 2008 à 22:45

0

Merci

Bas c'est clair. Pour un soft scientifique hors de question de faire un dégradé avec du rgb directement alors que pour du rendu temps réel 3D, ca peut s'imaginer.

Miquel75 · Answer 12 · 2008-04-01T08:31:54+0200

Signaler Commenter la réponse de Miquel75

Miquel75

Messages postés: 41
Date d'inscription: mercredi 5 mars 2008
Dernière intervention: 23 avril 2009

1 avril 2008 à 08:31

0

Merci

> Paint utilise HSL pour générer sont dégrader:

Evite de dire n'importe quoi.
J'ai le source de MSPaint sous les yeux...

luhtor · Answer 13 · 2008-04-01T13:22:46+0200

Signaler Commenter la réponse de luhtor

luhtor

Messages postés: 2023
Date d'inscription: mardi 24 septembre 2002
Dernière intervention: 28 juillet 2008

1 avril 2008 à 13:22

0

Merci

Il semble pourtant clair que le dégradé est généré dans l'espace HSL. Une seule des composantes varient suivant chaque axe, alors que ce n'est pas le cas pour les composantes rgb.

vecchio56 · Answer 14 · 2008-04-01T20:49:24+0200

Signaler Commenter la réponse de vecchio56

vecchio56

Messages postés: 6539
Date d'inscription: lundi 16 décembre 2002
Dernière intervention: 22 août 2010

1 avril 2008 à 20:49

0

Merci

D'après ce que je comprends, le HSL n'est utile que dans des cas très particuliers (si on prend un dégradé entre 2 couleurs quelconques, il y a forcément plusieurs composantes qui varient...)

_____________________________________

Pistol_Pete · Answer 15 · 2008-04-01T23:26:04+0200

Signaler Commenter la réponse de Pistol_Pete

Pistol_Pete

Messages postés: 1055
Date d'inscription: samedi 2 octobre 2004
Dernière intervention: 9 juillet 2013

1 avril 2008 à 23:26

0

Merci

Oui ca c'est certain que si on prend 2 couleurs aleatoirement et que l'on veux faire un dégrader entre ces deux couleurs, il y aura plusieurs composantes qui changeront.
Mais je maintiens que c'est plus facile de faire un dégrader en HSL

A+

vecchio56 · Answer 16 · 2008-04-01T23:36:44+0200

Signaler Commenter la réponse de vecchio56

vecchio56

Messages postés: 6539
Date d'inscription: lundi 16 décembre 2002
Dernière intervention: 22 août 2010

1 avril 2008 à 23:36

0

Merci

J'aimerais bien savoir en quoi c'est plus facile, car à part amener des calculs supplémentaires (pour faires les conversions), je ne vois pas ce que ca apporte.

_____________________________________

Pistol_Pete · Answer 17 · 2008-04-02T21:46:07+0200

Signaler Commenter la réponse de Pistol_Pete

Pistol_Pete

Messages postés: 1055
Date d'inscription: samedi 2 octobre 2004
Dernière intervention: 9 juillet 2013

2 avril 2008 à 21:46

0

Merci

Salut
Je te propose un petit jeu pour voir laquelle des deux méthodes est la plus facile a réaliser.
Le but du jeu est de reproduire à l'identique le dégradé de la boite de dialogue," modifier les couleurs" de MSPaint.
Miquel75 nous assurant (en ayant les code sous les yeux) qu'il est généré sans passez par le systeme HSL cela ne devrait pas posser de probleme pour le coder en RGB.

Il nous restera plusqu'a comparer la méthode la plus facile a implementer.

A+

vecchio56 · Answer 18 · 2008-04-02T22:05:57+0200

Signaler Commenter la réponse de vecchio56

vecchio56

Messages postés: 6539
Date d'inscription: lundi 16 décembre 2002
Dernière intervention: 22 août 2010

2 avril 2008 à 22:05

0

Merci

Pourquoi ne pas comparer les algos permettant de faire un dégradé entre 2 couleurs (puisque c'est le sujet de la discussion)?

_____________________________________

Pistol_Pete · Answer 19 · 2008-04-02T22:15:02+0200

Oui je veux bien mais le probleme c'est que l'on aura jamais le meme degrader avce nos deux alogorithmes...
Alors que la tu sais ce que tu dois obtenir.

Voila ma version HSL:

#define _WIN32_WINNT 0x0501
#define _WIN32_IE 0x0501
#include <windows.h>
//#include "resource.h"

HINSTANCE hinst;
HWND hmain;
char szappname[] = "Degrader";
HBITMAP hBmp;
UCHAR *ucBits=0;

double Hue_2_RGB(double v1,double v2,double vH )             //Function Hue_2_RGB
{
   if ( vH < 0 ) vH += 1;
   if ( vH > 1 ) vH -= 1;
   if ( ( 6 * vH ) < 1 ) return ( v1 + ( v2 - v1 ) * 6 * vH );
   if ( ( 2 * vH ) < 1 ) return ( v2 );
   if ( ( 3 * vH ) < 2 ) return ( v1 + ( v2 - v1 ) * ( ( 0.666666 ) - vH ) * 6 );
   return v1;
}

void HSL_to_RGB(double H,double S,double L,double *R,double *G,double*B)
{
    double tmp1,tmp2;
    H=(double)H/239;            //h,s,l compris entre 0 et 1
    S=(double)S/240;
    L=(double)L/240;

    if(S==0)
    {
        *R = 255 * L;
        *G = 255 * L;
        *B = 255 * L;
    }
    else
    {
        if(L<0.5)tmp2 = L * (1 + S);
        else tmp2 = (L + S) - (L * S);
        tmp1=2 * L - tmp2;

        *R = 255 * Hue_2_RGB( tmp1, tmp2, H + ( 0.333333 ) );
        *G = 255 * Hue_2_RGB( tmp1, tmp2, H );
        *B = 255 * Hue_2_RGB( tmp1, tmp2, H - ( 0.333333) );

    }
}
void DegraderHSL(UCHAR *ucBits)
{
    int i,j;
    double R,G,B;
    for(i=0;i<240;i++)
        for(j=0;j<240;j++) {
            HSL_to_RGB(i,240-j,120,&R,&G,&B);
            ucBits[(i+j*240)*4]=(int)B;
            ucBits[(i+j*240)*4+1]=(int)G;
            ucBits[(i+j*240)*4+2]=(int)R;
        }
}

LRESULT CALLBACK AppWndProc(HWND hwnd, UINT mssg, WPARAM wParam, LPARAM lParam)
{
    static int cx=800,cy=600;
    switch(mssg)
    {
    case WM_CREATE:
            ucBits = new UCHAR[240*240*4];
            if(ucBits==0)exit(0);
            hBmp=CreateBitmap(240,240,1,32,ucBits);
            memset(ucBits,0,240*240*4);
            DegraderHSL(ucBits);
            SetBitmapBits (hBmp,240*240*4,ucBits);

            break;

        case WM_PAINT:
            HDC hdc,hdcMem;
            HBITMAP hBmpTmp;
            PAINTSTRUCT ps;

            hdc = BeginPaint (hmain, &ps) ;
            hdcMem = CreateCompatibleDC(NULL);
            hBmpTmp = (HBITMAP)SelectObject(hdcMem,hBmp);

            SetStretchBltMode(hdc,HALFTONE);
            StretchBlt (hdc, 0, 0, cx, cy,hdcMem, 0, 0,240,240, MERGECOPY) ;

            DeleteObject(hBmpTmp);
            DeleteDC(hdcMem);

            EndPaint(hmain, &ps);
            break;
        case WM_SIZE:
            cx = LOWORD (lParam) ;
            cy = HIWORD (lParam) ;

            break;

        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
    return DefWindowProc(hwnd, mssg, wParam, lParam);
}

DWORD __stdcall InitInstance()
{
    WNDCLASSEX     wndcls;
    memset(&wndcls, 0, sizeof(WNDCLASSEX));
    wndcls.cbSize = sizeof(WNDCLASSEX);
    wndcls.lpfnWndProc   = AppWndProc;
    wndcls.style         = CS_HREDRAW | CS_VREDRAW;
    wndcls.hInstance     = hinst;
    wndcls.lpszClassName = szappname;
    wndcls.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
    wndcls.hCursor       = LoadCursor(0, IDC_ARROW);
    if(!RegisterClassEx(&wndcls)) return 0;
    hmain = CreateWindowEx(0, szappname, szappname, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, NULL, NULL, hinst, NULL);
    return (hmain != 0);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE x, PSTR y, int z)
{
    MSG msg;
    hinst = hInstance;
    if(!InitInstance()) return 0;
    ShowWindow(hmain, SW_NORMAL);
    while(GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return 0;
}

vecchio56 · Answer 20 · 2008-04-02T22:24:29+0200

Signaler Commenter la réponse de vecchio56

vecchio56

Messages postés: 6539
Date d'inscription: lundi 16 décembre 2002
Dernière intervention: 22 août 2010

2 avril 2008 à 22:24

0

Merci

C'est sur que pour ce dégradé-là, HSL est plus adapté, c'est d'ailleurs une sorte de représentation à mon sens de ce qu'est le codage HSL (tu fais varier H et S et tu obtiens ca).

_____________________________________

Dégradé de couleur en RGB [Résolu]

Votre réponse

Votre réponse

Votre réponse

Vous n'êtes pas encore membre ? inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !