Discussion :

[Gilbert Geyer]

Bonjour,

Je suis en-train de potasser les "Perlin noise" mais les codes que l'on trouve sur le net, lorsqu'ils sont intéressants sont codés en C.
Je suis donc en train d'en traduire un mais je bute sur quelques petits problèmes :

Pb n°1 :

Code :

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

n :=  (n << 13) ^ n ;  // n est un entier

... est ce que ceci signifie if n<13 then n:=(n à la puissance n); ???

Pb n°2 :

Code :

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

 corners = ( Noise1(x-1, y-1)+Noise1(x+1, y-1)+Noise1(x-1, y+1)\ +Noise1(x+1, y+1) ) / 16;

... que signifie le backslash '\' en rouge ???
... je suppose en plus que le slash '/' en vert c'est une division comme sous Delphi ??

Pb n°3 :

Code :

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

1
2
3
4
5
6
7
 return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7cfaffbf)\  / 1073741824.0 );

return ( 1.0 - ( (n * (n * n * 61493 + 324319) + 1000474303 ) & 0x6f4f45f1)\  / 1073741824.0 ); 

return ( 1.0 - ( (n * (n * n * 48647 + 901919) + 1600019251) & 0x7f3f4ff)\ / 1073741824.0 );

return ( 1.0 - ( (n * (n * n * 10243 + 3763247) + 1600017499) & 0x7f488f72)\ / 1073741824.0 );

... ici, en plus des pb de backslash j'aimerais savoir par quoi il faut remplacer les diverses valeurs du style & 0x6f4f45f1. Je suppose que le & se remplace par un simple and.

Pb n°4 avec la fonction suivante:

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
reel Perlin::PerlinNoise_2D(reel x, reel y) //< traduit par function PerlinNoise_2D(x,y : real) : real;
{
	reel total, amplitude;		          //< traduit par var total, amplitude : real;		
	entier i, frequency;		          //< traduit par var i, frequency : integer;				

	total = 0;
	  // Boucle maîtresse du noise Perlin
      for (i=0; i<octaves; i++)            // < traduit par for i:=0 to octaves-1 do begin  
      {
          frequency = (int)pow(2, i);      //< traduit par frequency = trunc(power(2, i));     
          amplitude = pow(persistence, i); //< traduit par amplitude = power(persistence, i);
          switch(i) //<- quel est l'équivalent de switch en Delphi
		  {
          case 0: total=total \ +InterpolatedNoise_1(x*frequency, y*frequency)*amplitude;
	       break;
	       case 1: total=total \ +InterpolatedNoise_2(x*frequency, y*frequency)*amplitude;
          break;
	       case 2: total=total \ +InterpolatedNoise_3(x*frequency, y*frequency)*amplitude;
          break;
	       case 3: total=total \ +InterpolatedNoise_4(x*frequency, y*frequency)*amplitude;
          break;
		  }
      }

      return total;
}

... là je suis complètement largué à partir du switch(i) et les case 0 à case 3. Sous Delphi on a des case QuelqueChose of c'est donc quoi ce QuelqueChose ici ?

Merci par avance aux âmes charitables qui me mettront sur la bonne piste.

A+.

[DOLPat®]

Une toute petite piste: Les valeurs précédées par 0x sont des nombres hexadécimaux. Donc 0x7f488f72 équivaut à $7f488f72 en Pascal.

[Edit]
Je viens de voir ceci qui pourra peut-être t'aider.

[Paul TOTH]

Bonjour,

Je suis en-train de potasser les "Perlin noise" mais les codes que l'on trouve sur le net, lorsqu'ils sont intéressants sont codés en C.
Je suis donc en train d'en traduire un mais je bute sur quelques petits problèmes :

Pb n°1 :

Code :

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

n :=  (n << 13) ^ n ;  // n est un entier

... est ce que ceci signifie if n<13 then n:=(n à la puissance n); ???

non << est l'opération shl, attention en C elle est signée, pas en Pascal
si je ne m'abuse '^' c'est XOR

Pb n°2 :

Code :

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

 corners = ( Noise1(x-1, y-1)+Noise1(x+1, y-1)+Noise1(x-1, y+1)\ +Noise1(x+1, y+1) ) / 16;

... que signifie le backslash '\' en rouge ???

ne serait-il pas sur une ligne #define ? dans ce cas c'est juste pour indiquer que la macro se poursuit sur la ligne suivante

... je suppose en plus que le slash '/' en vert c'est une division comme sous Delphi ??

Pb n°3 :

Code :

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

1
2
3
4
5
6
7
 return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7cfaffbf)\  / 1073741824.0 );

return ( 1.0 - ( (n * (n * n * 61493 + 324319) + 1000474303 ) & 0x6f4f45f1)\  / 1073741824.0 ); 

return ( 1.0 - ( (n * (n * n * 48647 + 901919) + 1600019251) & 0x7f3f4ff)\ / 1073741824.0 );

return ( 1.0 - ( (n * (n * n * 10243 + 3763247) + 1600017499) & 0x7f488f72)\ / 1073741824.0 );

... ici, en plus des pb de backslash j'aimerais savoir par quoi il faut remplacer les diverses valeurs du style & 0x6f4f45f1. Je suppose que le & se remplace par un simple and.

oui & et le AND binaire (alors que && est le AND boolean), 0x c'est le $ de la notion hexadécimale Attention aussi en C un nombre qui commence par 0 (et pas 0x) est en octal !

Pb n°4 avec la fonction suivante:

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
reel Perlin::PerlinNoise_2D(reel x, reel y) //< traduit par function PerlinNoise_2D(x,y : real) : real;
{
	reel total, amplitude;		          //< traduit par var total, amplitude : real;		
	entier i, frequency;		          //< traduit par var i, frequency : integer;				

	total = 0;
	  // Boucle maîtresse du noise Perlin
      for (i=0; i<octaves; i++)            // < traduit par for i:=0 to octaves-1 do begin  
      {
          frequency = (int)pow(2, i);      //< traduit par frequency = trunc(power(2, i));     
          amplitude = pow(persistence, i); //< traduit par amplitude = power(persistence, i);
          switch(i) //<- quel est l'équivalent de switch en Delphi
		  {
          case 0: total=total \ +InterpolatedNoise_1(x*frequency, y*frequency)*amplitude;
	       break;
	       case 1: total=total \ +InterpolatedNoise_2(x*frequency, y*frequency)*amplitude;
          break;
	       case 2: total=total \ +InterpolatedNoise_3(x*frequency, y*frequency)*amplitude;
          break;
	       case 3: total=total \ +InterpolatedNoise_4(x*frequency, y*frequency)*amplitude;
          break;
		  }
      }

      return total;
}

... là je suis complètement largué à partir du switch(i) et les case 0 à case 3. Sous Delphi on a des case QuelqueChose of c'est donc quoi ce QuelqueChose ici ?

le switch/case c'est le case of, mais attention, contrairement au pascal, le "case" est juste un label, si le code ne se termine pas par un break, le code du cas suivant s'execute, ça n'existe pas en Pascal :

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 switch (a) {
  case 1:
   // cas du 1 
  break;  // fin du cas 1
  case 2:
  // cas du 2
  // pas de break, donc le code suivant s’exécute également
  case 3:
  // suite du cas 2 - ou - cas 3
  break; // fin des cas 2 et 3
  }
}

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
 
label cas1, cas2, cas3;
begin
// équivalent Pascal (pas très propre mais ça illustre le principe)
  case a of
   1: goto cas1;
   2: goto cas2;
   3: goto cas3;
  end;
  cas1:
   ...
   goto endcase;
  cas2:
   ...
  cas3:
   ...
  endcase:
end;

Merci par avance aux âmes charitables qui me mettront sur la bonne piste.

A+.

[Gilbert Geyer]

Bonjour,

Mille fois merci à tous les deux. Je vais essayer de me débrouiller avec vos pistes.

A+.

[ShaiLeTroll]

non << est l'opération shl, attention en C elle est signée, pas en Pascal
si je ne m'abuse '^' c'est XOR

<< Signé ? Cela dépend du compilateur C
Le plus souvent (comme sous C++Builder)
<< Décalage à gauche, n'est pas signé pas ! (SHL)
>> Décalage à droite, conserve le signe ! (SAR)

N'est ce pas délirant comme choix !
Quand l'on sait que >>> n'est pas disponible en C !
Faut faire attention à ces int et unsigned !

Perso, je n'ai jamais eu besoin du signe lors de manipulation des Bits, je suis en C++Builder depuis un peu plus de 6 mois, j'ai découvert par hazard cette différence entre >> et << lors du sujet Conversion hexa avec nombre de byte variables



^ c'est effectivement XOR

[Gilbert Geyer]

Re-Bonjour,

ShaiLeTroll :^ c'est effectivement XOR

... merci pour cette confirmation.

A+.

[Gilbert Geyer]

Bonjour,

J'ai fini la traduction. Mais manque de chance les textures obtenues ne ressemblent pas à des textures "Perlin" ... excepté la texture "Bandes".

Code traduit :

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
interface
 
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls, Math;
 
type
  TfrmPerlin = class(TForm)
    Panel1: TPanel;
    bTextureNoiseStandard: TButton;
    bTextureTacheFloue: TButton;
    bTextureFeu: TButton;
    bTextureMarbre1: TButton;
    bTextureMarbre2: TButton;
    bTextureBois: TButton;
    bTextureBandes: TButton;
    bTextureSmoothBlanc: TButton;
    procedure bTextureNoiseStandardClick(Sender: TObject);
    procedure bTextureTacheFloueClick(Sender: TObject);
    procedure bTextureFeuClick(Sender: TObject);
    procedure bTextureMarbre1Click(Sender: TObject);
    procedure bTextureMarbre2Click(Sender: TObject);
    procedure bTextureBoisClick(Sender: TObject);
    procedure bTextureBandesClick(Sender: TObject);
    procedure bTextureSmoothBlancClick(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  frmPerlin: TfrmPerlin;
 
implementation
 
{$R *.DFM}
 
var     persistence : Double; // fixée par défaut à persistence := 0.5 dans section initialization
	octaves     : byte;   // fixée par défaut à octaves := 4 dans section initialization
 
 
procedure PerlinInit;
begin
end;
 
// **** Interpolation Cosinus *************************************************
 
function Cosine_Interpolate(a, b, x : Double) : Double;
var      ft, f : Double;
begin    ft:= x * PI;
	 f := (1 - cos(ft)) * 0.5;
	 Result:= a*(1-f) + b*f;
end;
 
// ==== PREMIER OCTAVE DE NOISE PERLIN ========================================
 
// **** Fonction de noise Perlin de base qui retourne un réel entre -1 et 1 ***
 
function Noise1( x, y : integer) : Double;
var      n : integer;
begin    n := x + y * 57;
         //n :=  (n << 13) ^ n ;
         n :=  (n shl 13) XOR n;
         //Return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7cfaffbf) / 1073741824.0 );
         Result:=( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) and $7cfaffbf) / 1073741824.0 );
end;
 
// **** Retourne un réel entre -1 et 1 pour une texture "smooth" **************
 
function SmoothNoise_1( x, y : integer) : Double;
var      corners, sides, center : Double;
begin
         corners := ( Noise1(x-1, y-1)+Noise1(x+1, y-1)+Noise1(x-1, y+1) +Noise1(x+1, y+1) ) / 16;
         sides   := ( Noise1(x-1, y)  +Noise1(x+1, y)  +Noise1(x, y-1) +Noise1(x, y+1) ) /  8;
         center :=  Noise1(x, y) / 4 ;
         Result:= corners + sides + center;
end;
 
// **** Interpolation des valeurs du noise Perlin *****************************
 
function InterpolatedNoise_1( x, y : Double) : Double;
var      Integer_X, Integer_Y : integer;
         fractional_X, fractional_Y : Double;
         v1, v2, v3, v4, i1, i2 : Double;
begin
         Integer_X     := Floor(x);
         fractional_X  := abs(x - Integer_X);
 
         Integer_Y     := Floor(y);
         fractional_Y  := abs(y - Integer_Y);
 
         v1 := SmoothNoise_1(Integer_X,     Integer_Y);
         v2 := SmoothNoise_1(Integer_X + 1, Integer_Y);
         v3 := SmoothNoise_1(Integer_X,     Integer_Y + 1);
         v4 := SmoothNoise_1(Integer_X + 1, Integer_Y + 1) ;
 
         i1 := Cosine_Interpolate(v1 , v2 , fractional_X);
         i2 := Cosine_Interpolate(v3 , v4 , fractional_X);
 
         Result:= Cosine_Interpolate(i1 , i2 , fractional_Y);
end;
 
// DEUXIÈME OCTAVE DE NOISE PERLIN :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
 
function Noise2(x, y : integer) : Double;
var      n : integer;
begin    n := x + y * 57;
         //n :=  (n << 13) ^ n;
         n :=  (n shl 13) XOR n;
         Result:= ( 1.0 - ( (n * (n * n * 61493 + 324319) + 1000474303 ) and $6f4f45f1) / 1073741824.0 );
end;
 
function SmoothNoise_2( x, y : integer) : Double;
var      corners, sides, center : Double;
begin    corners := ( Noise2(x-1, y-1)+Noise2(x+1, y-1)+Noise2(x-1, y+1) +Noise2(x+1, y+1) ) / 16;
         sides   := ( Noise2(x-1, y)  +Noise2(x+1, y)  +Noise2(x, y-1) +Noise2(x, y+1) ) /  8;
         center  :=  Noise2(x, y) / 4;
         Result:= corners + sides + center;
end;
 
function InterpolatedNoise_2(x,y : Double) : Double;
var      Integer_X, Integer_Y : integer;
         fractional_X, fractional_Y : Double;
         v1, v2, v3, v4, i1, i2 : Double;
begin
         Integer_X    := Floor(x);
         fractional_X := abs(x - Integer_X);
 
         Integer_Y    := Floor(y);
         fractional_Y := abs(y - Integer_Y);
 
         v1 := SmoothNoise_2(Integer_X,     Integer_Y);
         v2 := SmoothNoise_2(Integer_X + 1, Integer_Y);
         v3 := SmoothNoise_2(Integer_X,     Integer_Y + 1);
         v4 := SmoothNoise_2(Integer_X + 1, Integer_Y + 1) ;
 
         i1 := Cosine_Interpolate(v1 , v2 , fractional_X);
         i2 := Cosine_Interpolate(v3 , v4 , fractional_X);
 
         Result:=Cosine_Interpolate(i1 , i2 , fractional_Y);
end;
 
// :=:=:=:= TROISIÈME OCTAVE DE NOISE PERLIN :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
 
function Noise3(x, y : integer) : Double;
var      n : integer;
begin    n := x + y * 57;
         //n :=  (n << 13) ^ n;
         n :=  (n shl 13) XOR n;
         Result:= ( 1.0 - ( (n * (n * n * 48647 + 901919) + 1600019251) and $7f3f4ff) / 1073741824.0 );
end;
 
function  SmoothNoise_3(x, y : integer) : Double;
var       corners, sides, center : Double;
begin     corners := ( Noise3(x-1, y-1)+Noise3(x+1, y-1)+Noise3(x-1, y+1) +Noise3(x+1, y+1) ) / 16;
          sides   := ( Noise3(x-1, y)  +Noise3(x+1, y)  +Noise3(x, y-1) +Noise3(x, y+1) ) /  8;
          center  :=  Noise3(x, y) / 4;
          Result:= corners + sides + center;
end;
 
function  InterpolatedNoise_3( x, y : Double) : Double;
var       integer_X, integer_Y : integer;
          fractional_X, fractional_Y : Double;
          v1, v2, v3, v4, i1, i2 : Double;
 
begin     integer_X    := Floor(x);
          fractional_X := abs(x - integer_X);
 
          integer_Y    := Floor(y);
          fractional_Y := abs(y - integer_Y);
 
          v1 := SmoothNoise_3(integer_X,     integer_Y);
          v2 := SmoothNoise_3(integer_X + 1, integer_Y);
          v3 := SmoothNoise_3(integer_X,     integer_Y + 1);
          v4 := SmoothNoise_3(integer_X + 1, integer_Y + 1) ;
 
          i1 := Cosine_Interpolate(v1 , v2 , fractional_X);
          i2 := Cosine_Interpolate(v3 , v4 , fractional_X);
 
          Result:= Cosine_Interpolate(i1 , i2 , fractional_Y);
end;
 
// :=:=:=:= QUATRIÈMR OCTAVE DE NOISE PERLIN :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
 
function  Noise4( x,  y : integer) : Double;
var       n : integer;
begin     n := x + y * 57;
          //n :=  (n << 13) ^ n;
          n :=  (n shl 13) XOR n;
          Result:= ( 1.0 - ( (n * (n * n * 10243 + 3763247) + 1600017499) and $7f488f72) / 1073741824.0 );
end;
 
function  SmoothNoise_4( x, y : integer) : Double;
var       corners, sides, center : Double;
begin     corners := ( Noise4(x-1, y-1)+Noise4(x+1, y-1)+Noise4(x-1, y+1) +Noise4(x+1, y+1) ) / 16;
          sides   := ( Noise4(x-1, y)  +Noise4(x+1, y)  +Noise4(x, y-1) +Noise4(x, y+1) ) /  8;
          center  :=  Noise4(x, y) / 4;
          Result:= corners + sides + center;
end;
 
function  InterpolatedNoise_4( x, y : Double) : Double;
var       integer_X, integer_Y : integer;
          fractional_X, fractional_Y : Double;
          v1, v2, v3, v4, i1, i2 : Double;
begin
          integer_X    := Floor(x);
          fractional_X := abs(x - integer_X);
 
          integer_Y    := Floor(y);
          fractional_Y := abs(y - integer_Y);
 
          v1 := SmoothNoise_4(integer_X,     integer_Y);
          v2 := SmoothNoise_4(integer_X + 1, integer_Y);
          v3 := SmoothNoise_4(integer_X,     integer_Y + 1);
          v4 := SmoothNoise_4(integer_X + 1, integer_Y + 1) ;
 
          i1 := Cosine_Interpolate(v1 , v2 , fractional_X);
          i2 := Cosine_Interpolate(v3 , v4 , fractional_X);
 
          Result:=Cosine_Interpolate(i1 , i2 , fractional_Y);
end;
 
// :=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=
 
// Fonction noise Perlin qui génère la texture selon l'amplitude et la fréquence
 
function  PerlinNoise_2D( x, y : Double) : Double;
var       total, amplitude : Double;
	  i, frequence : integer;
begin
	  total := 0;
	  // Boucle maîtresse du noise Perlin
          for i:=0 to octaves-1 do begin
              frequence := trunc(power(2, i));
              amplitude := power(persistence, i);
              case i of
                   0 : total:=total + InterpolatedNoise_1(x*frequence, y*frequence)*amplitude;
                   1 : total:=total + InterpolatedNoise_2(x*frequence, y*frequence)*amplitude;
                   2 : total:=total + InterpolatedNoise_3(x*frequence, y*frequence)*amplitude;
                   3 : total:=total + InterpolatedNoise_4(x*frequence, y*frequence)*amplitude;
              end;
          end;
          Result:=total;
end;
 
// =================== TEXTURES ================================================
 
// **** Définition de la texture Perlin NoiseStandard **************************
 
function  textureNoiseStandard( u, v : Double) : tColor;
var       c : tColor;
          noise : Double;
	  R, G, B : Double; RP, GP, BP : byte;
begin
	  u := u*255;
	  v := v*255;
 
          persistence := 0.5;
	  octaves := 4;
          noise := PerlinNoise_2D(u, v);
 
          // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
          if (noise >= 0) then begin
             R := noise * 0.5 + 0.5;
             G := noise * 0.5 + 0.5;
             B := noise * 0.5 + 0.5;
          end else begin
             R := (-noise) * 0.5;
             G := (-noise) * 0.5;
             B := (-noise) * 0.5;
          end;
          RP:=trunc(255*R); GP:=trunc(255*G); BP:=trunc(255*B);
          c := RGB(RP,GP,BP);
	  Result:=c;
end;
 
 
// **** Définition de la texture Perlin TacheFloue ****************************
// effet taches floues : sum 1/f(f*noise) où f:=1 à x
 
function  textureTacheFloue(u, v : Double) : tColor;
var       c : tColor;
          noise : Double;
	  R, G, B : Double; RP,GP,BP : byte;
begin
          u := u*255 / 6;
          v := v*255 / 6;
 
          persistence := 0.5;
	  octaves := 4;
 
	  noise := PerlinNoise_2D(u, v);
	  noise := noise + (  1/2 * PerlinNoise_2D(2*u,  2*v));
          noise := noise + (  1/4 * PerlinNoise_2D(4*u,  4*v));
          noise := noise + (  1/6 * PerlinNoise_2D(8*u,  8*v));
          noise := noise + ( 1/16 * PerlinNoise_2D(16*u, 16*v));
          noise := noise + ( 1/32 * PerlinNoise_2D(32*u, 32*v));
 
          // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
          if (noise >= 0) then begin
             R := noise * 0.5 + 0.5;
             G := noise * 0.5 + 0.5;
             B := noise * 0.5 + 0.5;
          end else begin
             R := (-noise) * 0.5;
             G := (-noise) * 0.5;
             B := (-noise) * 0.5;
          end;
          RP:=trunc(255*R); GP:=trunc(255*G); BP:=trunc(255*B);
          c := RGB(RP,GP,BP);
 
	  Result:=c;
end;
 
// **** Définition de la texture Perlin Feu ***********************************
// effet turbulence de feu : sum 1/f(f*|noise|) où f:=1 à x
// prendre persistence := 0.5 et octave := 4
 
function  textureFeu( u,  v : Double) : tColor;
var       c : tColor;
          noise,R, G, B : Double; RP,GP,BP : byte;
begin
	  u := u*255 / 12;
          v := v*255 / 12;
          noise := 1.0;
 
          persistence := 0.5;
	  octaves := 4;
 
	  noise := abs(PerlinNoise_2D(u, v));
          noise := noise + (   1/2 * abs(PerlinNoise_2D(2*u,   2*v)));
          noise := noise + (   1/4 * abs(PerlinNoise_2D(4*u,   4*v)));
          noise := noise + (   1/6 * abs(PerlinNoise_2D(8*u,   8*v)));
          noise := noise + (  1/16 * abs(PerlinNoise_2D(16*u,  16*v)));
          noise := noise + (  1/32 * abs(PerlinNoise_2D(32*u,  32*v)));
          noise := noise + (  1/64 * abs(PerlinNoise_2D(64*u,  64*v)));
          noise := noise + ( 1/128 * abs(PerlinNoise_2D(128*u, 128*v)));
 
	  // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
	  // pour la couleur rouge et jaune, remplace code grayscale
          // noise vaut maintenant entre 0 (jaune) et 1 (rouge)
          R := 0.8;
          G := 0.6 * noise * 1.3;
          B := 0;
          RP:=trunc(255*R); GP:=trunc(255*G); BP:=trunc(255*B);
	  c := RGB(RP, GP, BP);
 
	  Result:=c;
end;
 
// **** Définition de la texture Perlin Marbre1 *******************************
// effet marbre : sin( u + sum 1/f(f*|noise|) ) où f:=1 à x
// prendre persistence := 0.6 et octave := 4
 
function  textureMarbre1(u, v : Double) : tColor;
var       c : tColor;
          noise : Double;
	  R, G, B : Double; RP, GP, BP : byte;
begin
          u := u*255 / 12;
          v := v*255 / 12;
 
          persistence := 0.6;
	  octaves := 4;
	  noise := abs(PerlinNoise_2D(u, v));
          noise := noise + ( 1/2 * abs(PerlinNoise_2D(2*u, 2*v)));
          noise := noise + ( 1/4 * abs(PerlinNoise_2D(4*u, 4*v)));
          noise := noise + ( 1/6 * abs(PerlinNoise_2D(8*u, 8*v)));
          noise := noise + ( 1/16 * abs(PerlinNoise_2D(16*u, 16*v)));
          noise := sin(u + 2*noise);
 
          // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
          if (noise >= 0) then begin
             R := noise * 0.5 + 0.5;
             G := noise * 0.5 + 0.5;
             B := noise * 0.5 + 0.5;
          end else begin
             R := (-noise) * 0.5;
             G := (-noise) * 0.5;
             B := (-noise) * 0.5;
          end;
 
          RP:=trunc(255*R); GP:=trunc(255*G); BP:=trunc(255*B);
	  c := RGB(RP, GP, BP);
	  Result:=c;
end;
 
// **** Définition de la texture Marbre2 **************************************
// effet marbre2
// prendre persistence := 0.1 et octave := 4
 
function  textureMarbre2(u, v : Double) : tColor;
var       c : tColor;
          noise,R, G, B : Double; RP, GP, BP : byte;
begin
          u := u*255 / 6;
          v := v*255 / 6;
          noise := 1.0;
 
          persistence := 0.1;
	  octaves := 4;
 
          noise := PerlinNoise_2D(u, v);
          noise := noise * 20;
          noise := noise - int(noise);
 
          // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
          if (noise >= 0) then begin
             R := noise * 0.5 + 0.5;
             G := noise * 0.5 + 0.5;
             B := noise * 0.5 + 0.5;
          end else begin
              R := (-noise) * 0.5;
              G := (-noise) * 0.5;
              B := (-noise) * 0.5;
          end;
          RP:=trunc(255*R); GP:=trunc(255*G); BP:=trunc(255*B);
	  c := RGB(RP, GP, BP);
	  Result:=c;
end;
 
// **** Définition de la texture Perlin Bois **********************************
// effet bois
// prendre persistence := 0.05 et octave := 4
 
function  textureBois(u, v : Double) : tColor;
var       c : tColor;
          noise,R, G, B : Double; RP, GP, BP : byte;
begin
          u := u*255 / 28;
          v := v*255 / 28;
          persistence := 0.05;
	  octaves := 4;
	  noise := PerlinNoise_2D(u, v);
          noise := noise * 20;
 
	  // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
	  // gradient rouge-mauve
	  if (noise >= 0) then begin
             R := 1;
             G := 0;
             B := noise * 0.5 + 0.5;
          end else begin
              R := 1;
              G := 0;
              B := (-noise) * 0.5;
          end;
 
	RP:=trunc(255*R); GP:=trunc(255*G); BP:=trunc(255*B);
        c := RGB(RP, GP, BP);
	Result:=c;
end;
 
// **** Définition de la texture Perlin Bandes ********************************
// bandes 2 couleurs
// mettre persistence à 1
 
function  textureBandes( u, v : Double) : tColor;
var       c : tColor;
          noise, noise2,R, G, B : Double; RP, GP, BP : byte;
begin
          u := u*255 / 2;
          v := v*255 / 2;
          persistence := 1.0;
	  octaves := 4;
          noise := PerlinNoise_2D(u, v);
          noise2 :=  sin( (u + noise*2.5) * 3.1416 / 4);
          noise := sqrt(abs(noise2));
          noise:=noise2;  // essayer aussi avec/sans faire cette ligne
 
          // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
          // gradient vert à bleu ciel
          if (noise >= 0) then begin
             R := 0.29;
             G := 0.68;
             B := noise * 0.5 + 0.5;
          end else begin
              R := 0.29;
              G := 0.68;
              B := (-noise) * 0.5;
          end;
 
          RP:=trunc(255*R); GP:=trunc(255*G); BP:=trunc(255*B);
	  c := RGB(RP, GP, BP);
	  Result:=c;
end;
 
// **** Définition de la texture Perlin SmoothBlanc ***************************
// effet smooth blanc
 
function  textureSmoothBlanc(u, v : Double) : tColor;
var       c : tColor;
          noise,R, G, B : Double; RP, GP, BP : byte;
begin
          u := u*255 /8;
          v := v*255 /8;
          persistence := 0.5;
	  octaves := 4;
          noise := PerlinNoise_2D(u, v);
	  noise := cos(noise);
 
	  // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
	  if (noise >= 0) then begin
	     R := noise * 0.5 + 0.5;
             G := noise * 0.5 + 0.5;
             B := noise * 0.5 + 0.5;
          end else begin
              R := (-noise) * 0.5;
              G := (-noise) * 0.5;
              B := (-noise) * 0.5;
          end;
          RP:=trunc(255*R); GP:=trunc(255*G); BP:=trunc(255*B);
	  c := RGB(RP, GP, BP);
	  Result:=c;
end;
 
// Utilisation : ===============================================================
 
const     xmin = 167; xmax = 422; // Pour texture de 255 x 255 pixels
          ymin =   7; ymax = 262; // Pour texture de 255 x 255 pixels
 
procedure TfrmPerlin.bTextureNoiseStandardClick(Sender: TObject);
var       x,y : integer;
begin     for x:=xmin to xmax do begin
              for y:=ymin to ymax do begin
                  Canvas.Pixels[x,y]:=textureNoiseStandard( x,y);
                  // Utilisation de Pixels[x,y] : suffisante pour un simple test
              end;
          end;
end;
 
procedure TfrmPerlin.bTextureTacheFloueClick(Sender: TObject);
var       x,y : integer;
begin     for x:=xmin to xmax do begin
              for y:=ymin to ymax do begin
                  Canvas.Pixels[x,y]:=textureTacheFloue( x,y);
              end;
          end;
end;
 
procedure TfrmPerlin.bTextureFeuClick(Sender: TObject);
var       x,y : integer;
begin     for x:=xmin to xmax do begin
              for y:=ymin to ymax do begin
                  Canvas.Pixels[x,y]:=textureFeu( y,x);
              end;
          end;
end;
 
procedure TfrmPerlin.bTextureMarbre1Click(Sender: TObject);
var       x,y : integer;
begin     for x:=xmin to xmax do begin
              for y:=ymin to ymax do begin
                  Canvas.Pixels[x,y]:=textureMarbre1( x,  y);
              end;
          end;
end;
 
procedure TfrmPerlin.bTextureMarbre2Click(Sender: TObject);
var       x,y : integer;
begin     for x:=xmin to xmax do begin
              for y:=ymin to ymax do begin
                  Canvas.Pixels[x,y]:=textureMarbre2( x,  y);
              end;
          end;
end;
 
procedure TfrmPerlin.bTextureBoisClick(Sender: TObject);
var       x,y : integer;
begin     for x:=xmin to xmax do begin
              for y:=ymin to ymax do begin
                  Canvas.Pixels[x,y]:=textureBois( x,  y);
              end;
          end;
end;
 
procedure TfrmPerlin.bTextureBandesClick(Sender: TObject);
var       x,y : integer;
begin     for x:=xmin to xmax do begin
              for y:=ymin to ymax do begin
                  Canvas.Pixels[x,y]:=textureBandes( x,  y);
              end;
          end;
end;
 
procedure TfrmPerlin.bTextureSmoothBlancClick(Sender: TObject);
var       x,y : integer;
begin     for x:=xmin to xmax do begin
              for y:=ymin to ymax do begin
                  Canvas.Pixels[x,y]:=textureSmoothBlanc( x,  y);
              end;
          end;
end;
 
initialization
 
          persistence := 0.5;
	  octaves     := 4;
 
END.

Original codé en C :

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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
/ ****************************************************************************
//
// 96574889  Simon Chrétien
// 98700374  Yves Grenier
//
// Travail Pratique Projet
// Présenté à M. Richard Egli
// le 27 novembre 2000
// IFT 528
//
// Perlin.cpp
//
// ****************************************************************************
 
#include <stdlib.h>
#include <math.h>
#include <fstream.h>
#include "couleur.h"
#include "perlin.h"
 
// **** Définition de la valeur absolue d'un réel *****************************
 
reel abs(reel valeur)
{
	if(valeur < 0) return (0 - valeur);
	else return valeur;
}
 
// **** Constructeur **********************************************************
 
Perlin::Perlin ()
{
	persistence = 0.5;
	octaves = 4;
}
 
// **** Interpolation Cosinus *************************************************
 
reel Perlin::Cosine_Interpolate(reel a, reel b, reel x)
{
	reel ft, f;
	ft = x * PI;
	f = (1 - cos(ft)) * 0.5;
	return  a*(1-f) + b*f;
}
 
// ==== PREMIER OCTAVE DE NOISE PERLIN ========================================
 
// **** Fonction de noise Perlin de base qui retourne un réel entre -1 et 1 ***
 
reel Perlin::Noise1(entier x, entier y)
{
    entier n;
    n = x + y * 57;
    n =  (n << 13) ^ n ;
    //return  (n mod (4+4)) - 4 / 4;
 
    return ( 1.0 - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7cfaffbf)\
		     / 1073741824.0 );
}
 
// **** Retourne un réel entre -1 et 1 pour une texture "smooth" **************
 
reel Perlin::SmoothNoise_1(entier x, entier y)
{
    reel corners, sides, center;
 
    corners = ( Noise1(x-1, y-1)+Noise1(x+1, y-1)+Noise1(x-1, y+1)\
		        +Noise1(x+1, y+1) ) / 16;
    sides   = ( Noise1(x-1, y)  +Noise1(x+1, y)  +Noise1(x, y-1)\
		        +Noise1(x, y+1) ) /  8;
    center  =  Noise1(x, y) / 4 ;
    return corners + sides + center;
}
 
// **** Interpolation des valeurs du noise Perlin *****************************
 
reel Perlin::InterpolatedNoise_1(reel x, reel y)
{
	entier Integer_X, Integer_Y;
    reel fractional_X, fractional_Y;
    reel v1, v2, v3, v4, i1, i2;
 
      Integer_X    = int(x);
      fractional_X = abs(x - Integer_X);
 
      Integer_Y    = int(y);
      fractional_Y = abs(y - Integer_Y);
 
      v1 = SmoothNoise_1(Integer_X,     Integer_Y) ;
      v2 = SmoothNoise_1(Integer_X + 1, Integer_Y) ;
      v3 = SmoothNoise_1(Integer_X,     Integer_Y + 1) ;
      v4 = SmoothNoise_1(Integer_X + 1, Integer_Y + 1)  ;
 
      i1 = Cosine_Interpolate(v1 , v2 , fractional_X);
      i2 = Cosine_Interpolate(v3 , v4 , fractional_X) ;
 
      return Cosine_Interpolate(i1 , i2 , fractional_Y) ;
}
 
// ==== DEUXIÈME OCTAVE DE NOISE PERLIN =======================================
 
reel Perlin::Noise2(entier x, entier y)
{
    entier n;
    n = x + y * 57;
    n =  (n << 13) ^ n ;
    return ( 1.0 - ( (n * (n * n * 61493 + 324319) + 1000474303 ) & 0x6f4f45f1)\
		     / 1073741824.0 );
}
 
reel Perlin::SmoothNoise_2(entier x, entier y)
{
    reel corners, sides, center;
    corners = ( Noise2(x-1, y-1)+Noise2(x+1, y-1)+Noise2(x-1, y+1)\
		        +Noise2(x+1, y+1) ) / 16;
    sides   = ( Noise2(x-1, y)  +Noise2(x+1, y)  +Noise2(x, y-1)\
		        +Noise2(x, y+1) ) /  8;
    center  =  Noise2(x, y) / 4 ;
    return corners + sides + center;
}
 
reel Perlin::InterpolatedNoise_2(reel x, reel y)
{
	entier Integer_X, Integer_Y;
    reel fractional_X, fractional_Y;
    reel v1, v2, v3, v4, i1, i2;
 
      Integer_X    = int(x);
      fractional_X = abs(x - Integer_X);
 
      Integer_Y    = int(y);
      fractional_Y = abs(y - Integer_Y);
 
      v1 = SmoothNoise_2(Integer_X,     Integer_Y) ;
      v2 = SmoothNoise_2(Integer_X + 1, Integer_Y) ;
      v3 = SmoothNoise_2(Integer_X,     Integer_Y + 1) ;
      v4 = SmoothNoise_2(Integer_X + 1, Integer_Y + 1)  ;
 
      i1 = Cosine_Interpolate(v1 , v2 , fractional_X);
      i2 = Cosine_Interpolate(v3 , v4 , fractional_X) ;
 
      return Cosine_Interpolate(i1 , i2 , fractional_Y) ;
}
 
// ==== TROISIÈME OCTAVE DE NOISE PERLIN ======================================
 
reel Perlin::Noise3(entier x, entier y)
{
    entier n;
    n = x + y * 57;
    n =  (n << 13) ^ n ;
    return ( 1.0 - ( (n * (n * n * 48647 + 901919) + 1600019251) & 0x7f3f4ff)\
		     / 1073741824.0 );
}
 
reel Perlin::SmoothNoise_3(entier x, entier y)
{
    reel corners, sides, center;
    corners = ( Noise3(x-1, y-1)+Noise3(x+1, y-1)+Noise3(x-1, y+1)\
		        +Noise3(x+1, y+1) ) / 16;
    sides   = ( Noise3(x-1, y)  +Noise3(x+1, y)  +Noise3(x, y-1)\
		        +Noise3(x, y+1) ) /  8;
    center  =  Noise3(x, y) / 4 ;
    return corners + sides + center;
}
 
reel Perlin::InterpolatedNoise_3(reel x, reel y)
{
      entier Integer_X, Integer_Y;
      reel fractional_X, fractional_Y;
      reel v1, v2, v3, v4, i1, i2;
 
      Integer_X    = int(x);
      fractional_X = abs(x - Integer_X);
 
      Integer_Y    = int(y);
      fractional_Y = abs(y - Integer_Y);
 
      v1 = SmoothNoise_3(Integer_X,     Integer_Y) ;
      v2 = SmoothNoise_3(Integer_X + 1, Integer_Y) ;
      v3 = SmoothNoise_3(Integer_X,     Integer_Y + 1) ;
      v4 = SmoothNoise_3(Integer_X + 1, Integer_Y + 1)  ;
 
      i1 = Cosine_Interpolate(v1 , v2 , fractional_X);
      i2 = Cosine_Interpolate(v3 , v4 , fractional_X) ;
 
      return Cosine_Interpolate(i1 , i2 , fractional_Y) ;
}
 
// ==== QUATRIÈMR OCTAVE DE NOISE PERLIN ======================================
 
reel Perlin::Noise4(entier x, entier y)
{
    entier n;
    n = x + y * 57;
    n =  (n << 13) ^ n ;
    return ( 1.0 - ( (n * (n * n * 10243 + 3763247) + 1600017499) & 0x7f488f72)\
		     / 1073741824.0 );
}
 
reel Perlin::SmoothNoise_4(entier x, entier y)
{
    reel corners, sides, center;
    corners = ( Noise4(x-1, y-1)+Noise4(x+1, y-1)+Noise4(x-1, y+1)\
		        +Noise4(x+1, y+1) ) / 16;
    sides   = ( Noise4(x-1, y)  +Noise4(x+1, y)  +Noise4(x, y-1)\
		        +Noise4(x, y+1) ) /  8;
    center  =  Noise4(x, y) / 4 ;
    return corners + sides + center;
}
 
reel Perlin::InterpolatedNoise_4(reel x, reel y)
{
	entier Integer_X, Integer_Y;
        reel fractional_X, fractional_Y;
        reel v1, v2, v3, v4, i1, i2;
 
      Integer_X    = int(x);
      fractional_X = abs(x - Integer_X);
 
      Integer_Y    = int(y);
      fractional_Y = abs(y - Integer_Y);
 
      v1 = SmoothNoise_4(Integer_X,     Integer_Y) ;
      v2 = SmoothNoise_4(Integer_X + 1, Integer_Y) ;
      v3 = SmoothNoise_4(Integer_X,     Integer_Y + 1) ;
      v4 = SmoothNoise_4(Integer_X + 1, Integer_Y + 1)  ;
 
      i1 = Cosine_Interpolate(v1 , v2 , fractional_X);
      i2 = Cosine_Interpolate(v3 , v4 , fractional_X) ;
 
      return Cosine_Interpolate(i1 , i2 , fractional_Y) ;
}
 
// ============================================================================
 
// Fonction noise Perlin qui génère la texture selon l'amplitude et la fréquence
 
reel Perlin::PerlinNoise_2D(reel x, reel y)
{
	reel total, amplitude;
	entier i, frequency;
 
	total = 0;
	  // Boucle maîtresse du noise Perlin
      for (i=0; i<octaves; i++)
      {
          frequency = (int)pow(2, i);
          amplitude = pow(persistence, i);
          switch(i)
		  {
          case 0: total=total \
			      +InterpolatedNoise_1(x*frequency, y*frequency)*amplitude;
		  break;
		  case 1: total=total \
			      +InterpolatedNoise_2(x*frequency, y*frequency)*amplitude;
          break;
		  case 2: total=total \
			      +InterpolatedNoise_3(x*frequency, y*frequency)*amplitude;
          break;
		  case 3: total=total \
			      +InterpolatedNoise_4(x*frequency, y*frequency)*amplitude;
          break;
		  }
      }
 
      return total;
}
 
// **** Définition de la texture Perlin NoiseStandard *************************
 
Couleur Perlin::textureNoiseStandard(reel u, reel v)
{
    persistence = 0.5;
	octaves = 4;
 
	Couleur c;
    double noise;
	reel R, G, B;
 
	u = u*255;
	v = v*255;
 
    noise = PerlinNoise_2D(u, v);
 
	// transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
	if (noise >= 0)
    {
		R = noise * 0.5 + 0.5;
        G = noise * 0.5 + 0.5;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = (-noise) * 0.5;
        G = (-noise) * 0.5;
        B = (-noise) * 0.5;
    }
	c = Couleur(R, G, B);
 
	return c;
}
 
// **** Définition de la texture Perlin TacheFloue ****************************
// effet taches floues : sum 1/f(f*noise) où f=1 à x
 
Couleur Perlin::textureTacheFloue(reel u, reel v)
{
    persistence = 0.5;
    octaves = 4;
 
    Couleur c;
    reel noise;
    reel R, G, B;
 
 
    u = u*255 / 6;
    v = v*255 / 6;
 
    noise = PerlinNoise_2D(u, v);
    noise = noise + ( 1/2 * PerlinNoise_2D(2*u, 2*v));
    noise = noise + ( 1/4 * PerlinNoise_2D(4*u, 4*v));
    noise = noise + ( 1/6 * PerlinNoise_2D(8*u, 8*v));
    noise = noise + ( 1/16 * PerlinNoise_2D(16*u, 16*v));
    noise = noise + ( 1/32 * PerlinNoise_2D(32*u, 32*v));
 
    // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
    if (noise >= 0)
    {
	R = noise * 0.5 + 0.5;
        G = noise * 0.5 + 0.5;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = (-noise) * 0.5;
        G = (-noise) * 0.5;
        B = (-noise) * 0.5;
    }
	c = Couleur(R, G, B);
 
	return c;
}
 
// **** Définition de la texture Perlin Feu ***********************************
// effet turbulence de feu : sum 1/f(f*|noise|) où f=1 à x
// prendre persistence = 0.5 et octave = 4
 
Couleur Perlin::textureFeu(reel u, reel v)
{
    persistence = 0.5;
    octaves = 4;
 
    Couleur c;
    reel noise = 1.0;
    reel R, G, B;
 
    u = u*255 / 12;
    v = v*255 / 12;
 
    noise = abs(PerlinNoise_2D(u, v));
    noise = noise + ( 1/2 * abs(PerlinNoise_2D(2*u, 2*v)));
    noise = noise + ( 1/4 * abs(PerlinNoise_2D(4*u, 4*v)));
    noise = noise + ( 1/6 * abs(PerlinNoise_2D(8*u, 8*v)));
    noise = noise + ( 1/16 * abs(PerlinNoise_2D(16*u, 16*v)));
    noise = noise + ( 1/32 * abs(PerlinNoise_2D(32*u, 32*v)));
    noise = noise + ( 1/64 * abs(PerlinNoise_2D(64*u, 64*v)));
    noise = noise + ( 1/128 * abs(PerlinNoise_2D(128*u, 128*v)));
 
    // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
    // pour la couleur rouge et jaune, remplace code grayscale
    // noise vaut maintenant entre 0 (jaune) et 1 (rouge)
    R = 0.8;
    G = 0.6 * noise * 1.3 ;
    B = 0; 
    c = Couleur(R, G, B);
 
    return c;
}
 
// **** Définition de la texture Perlin Marbre1 *******************************
// effet marbre : sin( u + sum 1/f(f*|noise|) ) où f=1 à x
// prendre persistence = 0.6 et octave = 4
 
Couleur Perlin::textureMarbre1(reel u, reel v)
{
    persistence = 0.6;
    octaves = 4;
 
    Couleur c;
    reel noise = 1.0;
    reel R, G, B;
 
    u = u*255 / 12;
    v = v*255 / 12;
 
    noise = abs(PerlinNoise_2D(u, v));
    noise = noise + ( 1/2 * abs(PerlinNoise_2D(2*u, 2*v)));
    noise = noise + ( 1/4 * abs(PerlinNoise_2D(4*u, 4*v)));
    noise = noise + ( 1/6 * abs(PerlinNoise_2D(8*u, 8*v)));
    noise = noise + ( 1/16 * abs(PerlinNoise_2D(16*u, 16*v)));
    noise = sin(u + 2*noise);
 
    // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
    if (noise >= 0)
    {
	R = noise * 0.5 + 0.5;
        G = noise * 0.5 + 0.5;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = (-noise) * 0.5;
        G = (-noise) * 0.5;
        B = (-noise) * 0.5;
    }
	c = Couleur(R, G, B);
 
	return c;
}
 
// **** Définition de la texture Marbre2 **************************************
// effet marbre2
// prendre persistence = 0.1 et octave = 4
 
Couleur Perlin::textureMarbre2(reel u, reel v)
{
    persistence = 0.1;
    octaves = 4;
 
    Couleur c;
    reel noise = 1.0;
    reel R, G, B;
 
    u = u*255 / 6;
    v = v*255 / 6;
 
    noise = PerlinNoise_2D(u, v);
    noise = noise * 20;
    noise = noise - int(noise);
 
    // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
    if (noise >= 0)
    {
	R = noise * 0.5 + 0.5;
        G = noise * 0.5 + 0.5;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = (-noise) * 0.5;
        G = (-noise) * 0.5;
        B = (-noise) * 0.5;
    }
	c = Couleur(R, G, B);
 
	return c;
}
 
// **** Définition de la texture Perlin Bois **********************************
// effet bois
// prendre persistence = 0.05 et octave = 4
 
Couleur Perlin::textureBois(reel u, reel v)
{
    persistence = 0.05;
    octaves = 4;
 
    Couleur c;
    reel noise = 1.0;
    reel R, G, B;
 
    u = u*255 / 28;
    v = v*255 / 28;
 
    noise = PerlinNoise_2D(u, v);
    noise = noise * 20;
 
    // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
    /*
    // gradient rouge-mauve
    if (noise >= 0)
    {
	R = 1;
        G = 0;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = 1;
        G = 0;
        B = (-noise) * 0.5;
    }
	*/
        if (noise >= 0)
    {
	R = noise * 0.5 + 0.5;
        G = noise * 0.5 + 0.5;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = (-noise) * 0.5;
        G = (-noise) * 0.5;
        B = (-noise) * 0.5;
    }
 
	c = Couleur(R, G, B);
 
	return c;
}
 
// **** Définition de la texture Perlin Bandes ********************************
// bandes 2 couleurs
// mettre persistence à 1
 
Couleur Perlin::textureBandes(reel u, reel v)
{
    persistence = 1.0;
    octaves = 4;
 
    Couleur c;
    reel noise, noise2 = 1.0;
    reel R, G, B;
 
    u = u*255 / 2;
    v = v*255 / 2;
 
    noise = PerlinNoise_2D(u, v);
    noise2 =  sin( (u + noise*2.5) * 3.1416 / 4);
    noise = sqrt(abs(noise2));
    noise=noise2;  // essayer aussi avec/sans faire cette ligne
 
    // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
 
    /*
    // gradient vert à bleu ciel
    if (noise >= 0)
    {
	R = 0.29;
        G = 0.68;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = 0.29;
        G = 0.68;
        B = (-noise) * 0.5;
    }
	*/
    // Pour texture noir et blanc
	if (noise >= 0)
    {
	R = noise * 0.5 + 0.5;
        G = noise * 0.5 + 0.5;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = (-noise) * 0.5;
        G = (-noise) * 0.5;
        B = (-noise) * 0.5;
    }
 
	c = Couleur(R, G, B);
 
	return c;
}
 
// **** Définition de la texture Perlin SmoothBlanc ***************************
// effet smooth blanc
 
Couleur Perlin::textureSmoothBlanc(reel u, reel v)
{
    persistence = 0.5;
    octaves = 4;
 
    Couleur c;
    reel noise = 1.0;
    reel R, G, B;
 
    u = u*255 /8;
    v = v*255 /8;
 
    noise = cos(noise * 8) ;
 
    // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
    if (noise >= 0)
    {
	R = noise * 0.5 + 0.5;
        G = noise * 0.5 + 0.5;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = (-noise) * 0.5;
        G = (-noise) * 0.5;
        B = (-noise) * 0.5;
    }
	c = Couleur(R, G, B);
 
	return c;
}

... En conséquence, de quatre choses l'une :
- Soit il reste une erreur de traduction,
- Soit il y a une embrouille dans les paramètres numériques,
- Soit il y a une erreur dans l'utilisation des routines,
- Soit le code en C est foireux ou incomplet. ???

Donc si une erreur vous saute aux yeux n'hésitez pas à me la signaler... mais ne perdez pas trop avec avec cela.

A+.

[Paul TOTH]

il me semble que tu t'es loupé sur les commentaires /* ... */ dans le calcul des textures

[Gilbert Geyer]

Re-bonjour,

Paul TOTH :il me semble que tu t'es loupé sur les commentaires /* ... */ dans le calcul des textures

... merci beaucoup c'est déjà une piste, j'ai dû mélanger des trucs.
... mais comme les commentaires n'agissent pas sur les calculs je ne pige pas bien.
... en tous cas je vais chercher les incohérences entre les commentaires et le code lui même.

Entre-temps j'ai essayé de traduire un autre bout de code en C et j'en profite pour deux petites questions :

1) J'ai la ligne suivante en C : g3[i][j] = (double)((rand() % (B + B)) - B) / B;
... g3 est déjà déclaré comme un double. Mais rand() c'est équivalent sous Delphi à Random(1) ? Et l'opérateur '%' en rouge c'est quoi en Delphi ???

2) J'ai aussi cette boucle qui m'intrigue :

Code :

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

1
2
3
4
5
6
  while (--i)
           {
              k = p[i];
              p[i] = p[j = rand() % B];
              p[j] = k;
           }

... cela se traduit-il par while i<0 ???

A+.

[Paul TOTH]

% c'est mod

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
 
(*
while (--i)
           {
              k = p[i];
              p[i] = p[j = rand() % B];
              p[j] = k;
           }
*)  
  while i > 1 do // ou > 0 j'ai un doute :)
  begin
    Dec(i);
    k := p[i];
    j = random() mod B; // ????
    p[i] := p[j];
    p[j] := k;
  end;

[Gilbert Geyer]

Re-bonjour,

Paul TOTH :il me semble que tu t'es loupé sur les commentaires /* ... */ dans le calcul des textures

.
... J'ai des /* ... */ par exemple dans la texture "Bois"

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
Couleur Perlin::textureBois(reel u, reel v)
{   ...
    ...
    // transforme la valeur finale noise de -1 à 1 en une couleur RGB grayscale
    /*
    // gradient rouge-mauve
    if (noise >= 0)
    {
	R = 1;
        G = 0;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = 1;
        G = 0;
        B = (-noise) * 0.5;
    }
	*/
        if (noise >= 0)
    {
	R = noise * 0.5 + 0.5;
        G = noise * 0.5 + 0.5;
        B = noise * 0.5 + 0.5;
    }
    else
    {
        R = (-noise) * 0.5;
        G = (-noise) * 0.5;
        B = (-noise) * 0.5;
    }
    ...
    ...
}

... est-ce-que ces /* ... */ en rouge agissent sur le code et comment ???
... Dans mon code j'ai carrément supprimé les lignes suivantes qui correspondent au deuxième if :
if (noise >= 0)
{
R = noise * 0.5 + 0.5;
G = noise * 0.5 + 0.5;
B = noise * 0.5 + 0.5;
}
else
{
R = (-noise) * 0.5;
G = (-noise) * 0.5;
B = (-noise) * 0.5;
}

A+.

Oups je m'aperçois que pendant que je rédigeais tu m'as répondu à mon message précédent.

[Gilbert Geyer]

Re-bonjour,

A Paul TOTH
Mille fois merci pour "% c'est mod" et pour la traduction du "while (--i)".

A+.

[Paul TOTH]

Re-bonjour,

A Paul TOTH
Mille fois merci pour "% c'est mod" et pour la traduction du "while (--i)".

A+.

et dans la précédent réponse je t'indique que les commentaires C++ sont /* */ comme (* et *) en Pascal

[Gilbert Geyer]

Re-bonjour,

Paul TOTH : et dans la précédent réponse je t'indique que les commentaires C++ sont /* */ comme (* et *) en Pascal
... merci beaucoup.
... Ce qui veut dire que le premier if n'est qu'un commentaire et manque de bol c'est le seul que j'avais conservé pour les couleurs.
... Mais apparemment c'est le deuxième if qu'il faut conserver puisqu'il est en-dehors de tout commentaire.
... Je vais voir ce que cela donne.

A+.

[Gilbert Geyer]

Re-bonjour,

Bon j'ai donc ignoré dans le code les lignes de commentaires placées entre les /* ... */ mais cela ne change que les couleurs des textures et les textures ne ressemblent toujours pas à des texture "Perlin" sauf la texture "Bandes".
Faut donc que je cherche l'erreur ailleurs. Mais peut-être que c'est le code en C qui est foireux ou incomplet ???
En tous cas stop pour aujourd'hui et merci pour toutes les réponses reçues.

A+.