Discussion :

[ywan42]

Bonjour à tous,

j'ai encore un probleme de dev.

J'ai un bitmap dégradé vert chaque pixel ayant la couleur (R,V,B) et je voudrais le convertir dans un degradé de ton bleu avec pour couleur de base (0,128,255) par exemple.

Pourrriez vous m'aider et me dire comment faire passer de (RVB) à (R',V',B') ?

Merci d'avance,
YWAN.

[ywan42]

et bé y'a personne qui a un tuyau sur ce genre de bidouille du RGB !!! ???

ou quoi ?

[Médinoc]

Tu peux essayer en permutant directement le vert et le bleu, sinon il faudra un truc plus "space"...

[buzzkaido]

Je suis pas sur que ça marche, mais tente une sorte d'interpolation :

Disons que tu a deux couleurs pour ton degradé de depart : couleur de depart et couleur d'arrivée :

(Rd,Vd,Bd) et (Ra,Va,Ba) leurs composantes RVB

Disons que tu as deux couleurs pour ton degradé d'arrivée : couleur de depart et couleur d'arrivée :

(R'd,V'd,B'd) et (R'a,V'a,B'a) leurs composantes RVB

Pour chaque composante, c'est la meme chose, donc j'explique pour le R.

Pour chaque pixel(R,V,B) de ton image de base, tu calcules la quantité de couleur de depart et de couleur d'arrivée :

Ca revient à determiner n et m tels que R = n*Rd + m*Ra

Evidemment, il faut une autre contrainte, paske comme ça, l'équation n'est pas solvable :

Par exemple, pour un degradé linéaire, tu as n + m = 1
donc R = n*Rd + (1-n)*Ra et m = 1-n

Ensuite, pour chaque pixel de ton image de destination, tu as R' = n*R'd + m*R'a

Je suis sûr de rien, ce n'est qu'une idée...

-----------------------------------

Si tes degradés partent du blanc ou du noir, tu peux aussi calculer la luminosité de chaque pixel de l'image source (en convertisant le pixel en niveau de gris, par exemple).

Puis pour chaque pixel de l'image destination, tu peux simplement multiplier les composante R,V,B de la couleur d'arrivée par la luminosité.

Evidemment, il faut aussi appliquer un coef pour "normaliser", par exemple 1/maxLuminosité



--------------------------------

Dans l'absolu, c'est surement plus simple et plus precis et plus rapide de construire ton nouveau degradé à partir de rien, à moins que ce ne soit une forme tres spéciale.

[ywan42]

Merci pour ton conseil, je vais essayer ta methode


mais je ne peux pas construire le degrade a partir de rien : en fait j'ai un degradé vert et je calcule une ombre portée sur ce fond degradé et je voudrais permuter la couleur de l'ombre du vert (dgrade) a un bleu degrade aussi ... je vais donc essayer ta methode.

[buzzkaido]

C'est pour calculer une ombre portée ?

Dans ce cas, c'est différent...

Le plus bourrin, mais le plus joli, ce serait un truc du genre :

Pour chaque pixel qui doit avoir une ombre, tu calcules pour chaque pixel de l'image qui est endessous un coef dependant de la distance et de l'orientation (ce coef doit tendre vers 0 : rapidement = petite ombre, lentement = grande ombre)

Tu accumules ces coef sur toute l'image, en les limitant à une valeur max.

Ensuite pour chaque pixel de l'image qui est dessous, tu ajoute du bleu multiplié par le coef...

Si tu utilise un logarithme ou un truc du genre pour la relation distance-coef, t'auras un truc joli. Si t'utilises une formule linéaire, ce serait plus "robotique"

Maitenant, si les calculs doivent aller vite alors tu peux precalculer une bitmap intégrant une transparence alpha :

- Pour chaque objet dont il faut afficher l'ombre, tu prends un HBITMAP un peu plus grand.
- Tu remplit ce HBITMAP de pixel transparents
- pour chaque pixel de la forme de base, tu ecrit un pixel bleu et opaque dans le HBITMAP
- tu applique un filtre du type "BLUR" dans la direction souhaitée : tu obtient une image bleu avec la forme de ton objet de base et qui se degrade dans la direction de l'ombrage.

Ensuite, quand tu dessines un objet, il suffit de coller cette bitmap (avec alphablt) sur l'image de fond et de dessiner l'objet. Aux memes coordonnées, bien sur.