Discussion :

[bappy]

Bonjour,

je ne sais pas si le terme de l'intitulé est correct mais je ne trouve pas de nom d'algorithme pour ce que je veux faire.

J aimerai , à partir d'une photo, pouvoir générer une map en niveau de gris représentant la lumiere-luminescence que chaque pixel recoit...

pour exemple, le pluggin akvis decorator pour photoshop (attention ce n est pas de la pub pour ce pluggin, c est juste le seul moyen que j ai trouvé pour expliquer le concept) permet de remplacer la texture d'un objet sur une image par une autre texture, et ceci en gardant les ombre portées, intensité de la lumière etc.

j'essai de refaire le même system mais je ne comprend pas comment il peuvent acquerir le coefficient de lumiere sur un pixel....

si quelqu un à une once de réponse et une autre solution à proposé je suis preneur.

cdlt,

[bappy]

j ai continué mes recherches et je pense avoir trouvé quelque chose.

pour continuer d'expliquer ce que je recherche , j ai trouvé dans ce doc ce qui pourrait correspondre à mes attentes :
http://www.cv.its.hiroshima-cu.ac.jp/~baba/Shadow/

en fait il faut que j'arrive à générer l'image (b) du doc, la shadow density image....

j avoue avoir du mal a retranscrire l'algo en code...

[pseudocode]

en fait il faut que j'arrive à générer l'image (b) du doc, la shadow density image....

j avoue avoir du mal a retranscrire l'algo en code...

Je suppose que c'est la différence de luminosité entre l'image originale et l'image de reflectance (invariant).

google "Intrinsic images by entropy minimization".

[bappy]

merci, effectivement cela semble etre le cas.

un article en parle :
http://web.mit.edu/persci/people/ade...ps02_final.pdf

ce serai la shading ou shape image...

en revanche j avoue qu'en math j attend mes limites.. est ce que quelqu'un pourrais m'expliquer cette formule ?

"If fx and fy are the filters used to compute the x and y derivatives and Fx and Fy are the estimated derivatives of
shading image, then the shading image, S(x; y) is:
S(x; y) = g * [(fx(-x;-y) * Fx) + (fy(-x;-y) * Fy)] (1)

where * is convolution, f(-x;-y) is a reversed copy of f(x; y), and g is the solution of
g * [(fx(-x;-y) * fx(x; y)) + (fy(-x;-y) * fx(x; y))] = µ (2) "

[pseudocode]

merci, effectivement cela semble etre le cas.

un article en parle :
http://web.mit.edu/persci/people/ade...ps02_final.pdf

ce serai la shading ou shape image...

en revanche j avoue qu'en math j attend mes limites.. est ce que quelqu'un pourrais m'expliquer cette formule ?

J'ai trouvé une mise en oeuvre plus compréhensible de cette méthode dans le document "Weighted Map for Reflectance and Shading Separation Using a Single Image" (dispo sur internet).

[bappy]

merci pseudocod,

j ai trouvé l'article et j essai de l'implementer.

suivant le graph, je dois faire les etapes suivantes :
1 transformation logarithmic
2 convolution de 1 -> deux images (Pourquoi deux image ?)

3 Calcul de LUMRGBY
4 convolution de 3
5 creation weight map

6 classification des image généré en 2 grace a weight map(5)
7 reconstruction des image shading et reflectance


j ai fait les etape 1 et 3 mais
je ne comprend pas comment implementé en code la convolution de l'etape 2 (je suis en c#) y a t il une lib mathematique qui fait ca ou pourrais tu m expliquer comment coder ca?

[pseudocode]

j ai fait les etape 1 et 3 mais je ne comprend pas comment implementé en code la convolution de l'etape 2 (je suis en c#) y a t il une lib mathematique qui fait ca ou pourrais tu m expliquer comment coder ca?

Il s'agit de faire un filtrage linéaire locale. C'est à dire, pour chaque pixel de l'image, de multiplier le voisinage du pixel par un masque. J'ai essayé d'expliquer le principe ici :

http://xphilipp.developpez.com/artic...=page_3#LIII-B

Les 2 masques a employer pour calculer les dérivées fx et fy sont généralement PREWITT, ROBERTS ou SOBEL. Mais dans le document que j'ai indiqué, ils utilisent un masque plus simple : [0, -1, 1]. C'est à dire:

Fx( pixel(x,y) ) = (0)*pixel(x-1,y) + (-1)*pixel(x,y) + (1)*pixel(x+1,y)
Fy( pixel(x,y) ) = (0)*pixel(x,y-1) + (-1)*pixel(x,y) + (1)*pixel(x,y+1)

[bappy]

ok pour la convolution.

je revient sur le calcul de LUMRGBY.

j ai repris l'image du doc que tu m'as indiqué.
mon LUM semble etre correcte, en revanche, mes RG et BY sont presque noir.

les images qu'ils obtiennent en 4b et 4c m'etonnent car suivant leur formules, on a :

Par exemple pour un rouge (255,0,0)
le LMS donne :
L = 0.3811*255 + 0.5783*0 + 0.0402*0;
M = 0.1967*255 + 0.7244*0 + 0.0782*0
S = 0.0241*255 + 0.1288*0 + 0.8444*0

soit LMS (97.18, 50.16, 6.14)
ensuite LUMRGBY :
LUM = L+M ->147.34
RG = (L - M) / LUM -> (97.18 - 50.16)/147.34 =0.31
BY = ((S - 0.5)*LUM) / ((S+0.5) * LUM) = ((6.14-0.5)*147.34) / ((6.14+0.5)*147.34) = 0.85

donc RG et BY sont pratiquement à 0. comment obtiennent ils ces images...

[pseudocode]

Je pense que les composantes R,G,B doivent être entre 0 et 1 (réel), et pas entre 0 et 255 (entier).

[bappy]

bon j ai reussi a générer ma gradient shadow map. c est une image en derive de gris qui represente les ombres et lumieres (lightmap).

j aimerai savoir comment "multiplier" cette map par une autre image pour appliquer l'illumination de ma gradient map sur mon image.

je n'obtiens pas des resultats satisfaisant avec cette methode.

pour chaque pixel
dest[x][y] = new Color( dest[x][y].Hue, dest[x][y].Saturation, gradientmap[x][y].Brigthness);

Y a t il une autre maniere ?

[bappy]

j ai trouve quand faisant

dst[x][y] = new color(texture.R * shadow.brightness,texture.G * shadow.brightness,texture.B * shadow.brightness)

sachant que shadow.brightness[0,1]

on obtient des resultats satisfaisant. est ce la bonne formule ?

[pseudocode]

j ai trouve quand faisant

dst[x][y] = new color(texture.R * shadow.brightness,texture.G * shadow.brightness,texture.B * shadow.brightness)

sachant que shadow.brightness[0,1]

on obtient des resultats satisfaisant. est ce la bonne formule ?

Oui, ca m'a l'air d'être ça.