Méthode de calcul pour fusionner une NormaMap ?

**der§en** · 16/09/2019, 10h11

Bonjour,

J'ai cherché sur la toile sans trouver un algo ou un bout de code pour une question qui me semblait simple à la base :

Comment fusionner (comme sous OpenGL) une image NormalMap à l'image originelle ?

Voici l’image originelle (pour test) :
Nom : 256.jpg
Affichages : 282
Taille : 28,9 Ko

Nom : 256.jpg
Affichages : 282
Taille : 28,9 Ko

Voici la NormalMap :
Nom : NormalMap.jpg
Affichages : 286
Taille : 16,5 Ko

J'ai bien essayé ceci, comme pour une lightmap, mais le résultat ne me semble pas celui qui devrait être :

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
 
var
  Ab, Bb, Cb: PRGBTriple;
  X, Y: integer;
Begin
     fus.Picture.bitmap.Width  := ori.Picture.Width;
     fus.Picture.bitmap.Height := ori.Picture.Height;
 
     fus.Picture.Bitmap.BeginUpdate;
 
     for Y := 0 to ori.Picture.Height - 1 do
     begin
        Ab := PRGBTriple(ori.Picture.Bitmap.RawImage.GetLineStart(Y));
        Bb := PRGBTriple(map.Picture.Bitmap.RawImage.GetLineStart(Y));
        Cb := PRGBTriple(fus.Picture.Bitmap.RawImage.GetLineStart(Y));
 
        for X := 0 to ori.Picture.Width - 1 do
        begin
          Cb^.rgbtRed   := Trunc(Ab^.rgbtRed * (Bb^.rgbtRed / 255));
          Cb^.rgbtGreen := Trunc(Ab^.rgbtGreen * (Bb^.rgbtGreen / 255));
          Cb^.rgbtBlue  := Trunc(Ab^.rgbtBlue * (Bb^.rgbtBlue / 255));
 
          Inc(Cb);
          Inc(Bb);
          Inc(Ab);
        End;
     End;
 
     fus.Picture.Bitmap.EndUpdate;
 
     fus.Invalidate;

A votre avis, quel est la bonne méthode ?

**Paul TOTH** · 16/09/2019, 14h28

euh...qu'est ce que tu attends de la fusion d'une image et d'une normal map ?!

ce sont deux textures utilisées pour faire un rendu avec un éclairage perpixel, mais tu ne peux pas calculer une image résultante... ?! sauf à vouloir calculer l'image éclairée sous un angle donné.

les "couleurs" de la normal map sont en fait des vecteurs normaux à l'image pour chaque pixel, à partir d'un vecteur de lumière il est donc possible de calculer l'éclairage de chaque pixel.

**der§en** · 16/09/2019, 15h30

Je pensait pouvoir renforcer l'impression de 3D sur un bitmap avec, en fait...

**Lung** · 17/09/2019, 08h02

Envoyé par der§en

Je pensait pouvoir renforcer l'impression de 3D sur un bitmap avec, en fait...

Tu veux parler de bump mapping ?

**der§en** · 17/09/2019, 08h46

En suivant ton lien, je suis tombé sur cela, est c'est exactement ce que je veux faire sur une simple image:

Nom : a200203-17.jpg
Affichages : 240
Taille : 19,9 Ko

Il me reste plus qu'a trouvé comment procédé.

Si vous avez des liens sur des bouts d'algo en Pascal, je suis preneur...

**Paul TOTH** · 17/09/2019, 14h06

voici rapidement ce que ça pourrait donner...j'ai tenté d'utilise HSL mais ce n'était pas convainquant

comme le calcul dépend de la source d'éclairage, je l'ai rendu dynamique sur le MouseMove (il y a d'ailleurs un bug car je ne tient pas compte de la taille du TImage source dans "ax - 127"...mais c'est pas très grave)

SoftwareNormalMapping.zip

**der§en** · 17/09/2019, 15h40

1000 mercis Paul, je m'en vais tester ton code avec gourmandise

**der§en** · 17/09/2019, 17h13

Quand je vois ceci, peux-tu me si le 127 correspond a la moitié de la hauteur et de la largeur de l'image ?

Code :

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

1
2
3
4
5
 
  Light.x := ax - 127;
  Light.y := ay - 127;
  Light.z := 255;
  Light.Normalize;

Et que si je travaille avec une image plus grande, je dois changer cette valeur ?

**Paul TOTH** · 17/09/2019, 17h51

Envoyé par der§en

Quand je vois ceci, peux-tu me si le 127 correspond a la moitié de la hauteur et de la largeur de l'image ?

Code :

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

1
2
3
4
5
 
  Light.x := ax - 127;
  Light.y := ay - 127;
  Light.z := 255;
  Light.Normalize;

Et que si je travaille avec une image plus grande, je dois changer cette valeur ?

ben en fait peu importe, j'ai pris ces valeurs pour faire varier le vecteur source de lumière, dans ton cas je suppose que tu veux une image statique (sinon autant passer par OpenGL, le résultat sera meilleur...D'ailleurs rien n'interdit de passer par OpenGL dans tous les cas

)

**BeanzMaster** · 17/09/2019, 19h00

Salut

C'est ce genre de truc que tu souhaite faire :

j'ai réalisé cette demo avec Lazarus et ma bibliothèque en cours de dev.

Le code devrait être facilement transposable pour une utilisation avec un TBitmap ou autre. Je t'ai également mis les images que j'ai utilisée

Les images etant assez grosse je les mets ici

Nom : bump_diffuseOriginal02.png
Affichages : 248
Taille : 1,30 Mo

Nom : bump_diffuseOriginal02.png
Affichages : 248
Taille : 1,30 Mo

Nom : bump_heightmap02.png
Affichages : 232
Taille : 934,8 Ko

Nom : bump_metallic.png
Affichages : 233
Taille : 224,9 Ko

Nom : bump_normmap01.jpg
Affichages : 221
Taille : 227,3 Ko

Nom : phongmap.png
Affichages : 218
Taille : 93,6 Ko

A+

Bump.zip

**der§en** · 18/09/2019, 09h47

Merci pour le code, je vais tacher d'en extraire, la partie qui m’intéresse

**Paul TOTH** · 18/09/2019, 11h16

Envoyé par der§en

Merci pour le code, je vais tacher d'en extraire, la partie qui m’intéresse

elle n'est pas dedans

par contre BeanzMaster, tu peux peut-être compléter ou corriger mon code sur le calcul de la couleur d'un pixel d'après la normal map et un vecteur de lumière normalisé.

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
 
type
  TVector = record
    x, y, z: Single;
    procedure Normalize;
  end;
 
procedure TVector.Normalize;
var
  L: Single;
begin
  L := Sqrt(x * x + y * y + z * z);
  x := x / L;
  y := y / L;
  z := z / L;
end;
 
procedure ComputePixel(var Pixel: TRGBQuad; const Normal: TRGBQuad; const Light: TVector);
var
  dotProduct: Single;
  Vector: TVector;
begin
  Vector.X :=  (Normal.rgbRed / 255) - 0.5;
  Vector.Y :=  (Normal.rgbGreen / 255) - 0.5;
  Vector.Z :=  (Normal.rgbBlue / 255) - 0.5;
  Vector.Normalize;
 
  dotProduct := Vector.X * Light.x + Vector.Y * Light.y + Vector.Z * Light.z;
 
  if dotProduct < 0 then
    dotProduct := 0
  else
  if dotProduct > 1 then
    dotProduct := 1;
 
  Pixel.rgbRed := Round(Pixel.rgbRed * dotProduct);
  Pixel.rgbGreen := Round(Pixel.rgbGreen * dotProduct);
  Pixel.rgbBlue := Round(Pixel.rgbBlue * dotProduct);
end;

**BeanzMaster** · 19/09/2019, 21h27

Salut

Envoyé par Paul TOTH

elle n'est pas dedans

Comment ça ? si, si tout est dedans

Envoyé par Paul TOTH

par contre BeanzMaster, tu peux peut-être compléter ou corriger mon code sur le calcul de la couleur d'un pixel d'après la normal map et un vecteur de lumière normalisé.

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
 
type
  TVector = record
    x, y, z: Single;
    procedure Normalize;
  end;
 
procedure TVector.Normalize;
var
  L: Single;
begin
  L := Sqrt(x * x + y * y + z * z);
  x := x / L;
  y := y / L;
  z := z / L;
end;
 
procedure ComputePixel(var Pixel: TRGBQuad; const Normal: TRGBQuad; const Light: TVector);
var
  dotProduct: Single;
  Vector: TVector;
begin
  Vector.X :=  (Normal.rgbRed / 255) - 0.5;
  Vector.Y :=  (Normal.rgbGreen / 255) - 0.5;
  Vector.Z :=  (Normal.rgbBlue / 255) - 0.5;
  Vector.Normalize;
 
  dotProduct := Vector.X * Light.x + Vector.Y * Light.y + Vector.Z * Light.z;
 
  if dotProduct < 0 then
    dotProduct := 0
  else
  if dotProduct > 1 then
    dotProduct := 1;
 
  Pixel.rgbRed := Round(Pixel.rgbRed * dotProduct);
  Pixel.rgbGreen := Round(Pixel.rgbGreen * dotProduct);
  Pixel.rgbBlue := Round(Pixel.rgbBlue * dotProduct);
end;

Je n'avais pas vu ton code Paul

Je vais y jeter un oeil et le fusionner avec le mien, plus quelques explications en commentaire sur l'algo

Merci
A+

Jérôme

**Paul TOTH** · 19/09/2019, 22h45

Envoyé par BeanzMaster

Salut

Comment ça ? si, si tout est dedans

Jérôme

ben je sais pas, Lazarus me dit qu'il manque les paquets bzscene_rt et bzscene_image_rt qui ne sont pas dans le ZIP et que je ne trouve pas par ailleurs...je suppose que c'est le code sur lequel tu bosses non ?

**BeanzMaster** · 20/09/2019, 19h56

Envoyé par Paul TOTH

ben je sais pas, Lazarus me dit qu'il manque les paquets bzscene_rt et bzscene_image_rt qui ne sont pas dans le ZIP et que je ne trouve pas par ailleurs...je suppose que c'est le code sur lequel tu bosses non ?

Oui effectivement, les paquets ne sont pas présent. Je pensais que tu parlais du code pour générer le bump. Et tu supposes bien, c'est bien la bibliothèque que je développe depuis un petit moment déja.
Je m'en suis d'ailleurs servie a l'occasion de la Game Jam organisée par LittleWhite ici sur DVP : https://www.developpez.net/forums/d2...e-edition-dvp/
Malheureusement est elle bien trop grosse pour tenir dans le zip sur le forum.
Dès que j'aurais peaufiner encore un peu je rendrais le code source disponible sur Github

**der§en** · 24/09/2019, 16h35

La réponse qu'attends Paul, m’intéresse aussi beaucoup

**gbegreg** · 25/09/2019, 13h55

Bonjour,

Joli travail BeanzMaster

Pour info, il y a toujours les très bons exemples Delphi/OpenGL de Jan Horns (http://www.sulaco.co.za). De mémoire, il y a un exemple de bumpmapping.
Il y a aussi ce petit tuto (en allemand) : https://wiki.delphigl.com/index.php/Tutorial_BumpMap.

Méthode de calcul pour fusionner une NormaMap ?

Delphi

Discussions similaires

Partager

Partager