Discussion :

[niocco]

salut
j'ai lu bcp de litterature sur les thread et les canvas en delphi mais je bloque quand même.
Je m'explique : j'ai sur ma fiche une paintbox dans laquelle je fais des manipulations au niveau pixel du canvas ( pb1.canvas.pixels[x,y] := couleur )
mais ca prends du temps ( qq secondes ) d'ou l'idée de faire ce calcul dans un bitmap séparé mais la j'ai des gros soucis et je dois dire que je ne comprends pas toujours ce que je lis sur le net..
voila ce que j'ai fait et qui ne marche pas :

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
 
constructor TPaintThread.create(width, height: integer; m: TTempMap);
begin
  bmp := graphics.TBitmap.create;
  bmp.Width := width;
  bmp.Height := height;
  map := m;
  inherited create( false );
end;
 
procedure TPaintThread.Execute;
var
  i, j, a, b : integer;
  c: Tcolor;
  pas: integer;
begin
  inherited;
    while not Terminated do
    begin
      pas := 1;
      i := 0;
      j := 0;
      a := 0;
      b := 0;
      bmp.canvas.Pen.Style := psSolid;
      bmp.canvas.Pen.Mode := pmCopy;
      bmp.Canvas.Brush.Style := bsSolid;
      while j < Map.height - 1 do
      begin
        while i < Map.width - 1 do
        begin
          c := TempToColor( Map.Temps[i,j], Map.defaultTemperature, Map.maxTemp, Map.minTemp );
          bmp.Canvas.Pixels[i,j] := c;
          a := a + 1;
          i := a * pas;
        end;
        a := 0;
        i := 0;
        b := b + 1;
        j := b * pas;
      end;
      //c := rgb( random( 255 ), random( 255 ), random( 255 ));
      //bmp.canvas.brush.color := c;
      //bmp.Canvas.Rectangle( 0, 0, 50, 50 );
 
      synchronize( updateCanvas );
    end;
end;
 
procedure TPaintThread.updateCanvas;
begin
  FLifeGame.PaintBox1.Canvas.Draw(0,0,bmp);
end;

le résultat c'est que rien ne se peint dans la paintbox. et regulierement j'ai des messages d'erreurs d'accessviolation quand je ferme ma fiche.

pouvez vous me dire ce que je fais mal ?

[Paul TOTH]

1) regarde les multiples explications sur ScanLine que tu trouveras ici pour avoir un accès rapide aux pixels

2) la PaintBox n'a pas de mémoire, il me semblerait plus judicieux de faire une copie du bmp dans un bitmap appartenant à la fiche et d'invalider la PaintBox qui utilisera le second bitmap pour se dessiner (ou utiliser le bitmap d'un TImage)

[niocco]

En effet, pour une raison que je ne m'explique pas, en declarant une variable bmp dans le thread principal, ca fonctionne. ( bon j'ai fait d'autres manips aussi donc ca peut venir de la aussi, difficile d'en etre sur ). comme je ne comprends rien, j'aimerais des eclaircissement sur le principe des thread pour savoir si le mien est cohérent :
comme montré plus haut je calcule dans une boucle infinie du thread.execute la couleur de chaque pixel d'un bmp interne au thread.
J'ai implémenté un methode getBitmap dans le thread qui permet de le récupérer dans le onpaint de la paintbox. Et la j'appelle draw.

ps : merci pour le scanline je vais voir ca de suite


edit: je disais ca fonctionne, mais il y a des grosses bavures....

[niocco]

sur la capture : les "bavures"... auelqu'un sait il a quoi c'est du et comment l'éviter ? tant pis pour le frame rate mais il faut que je puisse visualiser une image non altérée.

par contre apres un essai tout simple avec scanline au lieu d'appels a pixels[x,y], j'ai constater une forte degradations des performances : je veux dire par la que la fenetre dans le thread principale était "bloquée" a de nombreuses reprises, comme si la boucle etait faite dans le thread principal et non dans un thread séparé... il doit me manquer des infos, mais dans le forum en tapant scanline je n'ai pas trouvé tellement de littératures si vous avez un lien ca m'aiderait bien

[Andnotor]

Cette instance de TTempMap devrait être une copie à usage unique du thread secondaire. Il ne faut pas espérer qu'il traite correctement cette donnée si la tâche principale la modifie constamment

par contre apres un essai tout simple avec scanline au lieu d'appels a pixels[x,y], j'ai constater une forte degradations des performances : je veux dire par la que la fenetre dans le thread principale était "bloquée" a de nombreuses reprises

Scanline n'est qu'un pointeur sur le premier pixel d'une image de résolution connue. Pixels[] est une fonction beaucoup plus complexe qui permet de faire abstraction de la résolution. Du 8, 16 ,24 ou 32 bits seront gérés de la même façon dans l'application, mais au prix de conversions non négligeables. Dans ton code et si Scanline est correctement traité, Synchronize est appelé beaucoup plus fréquemment et par conséquent... le thread principal bloqué plus souvent

Le mieux est toujours d'avoir un bitmap en traitement pendant qu'un deuxième est affiché. Le thread secondaire doit simplement annoncer qu'une nouvelle image est prête, mais pas s'occuper de son affichage.

[Paul TOTH]

sur la capture : les "bavures"... auelqu'un sait il a quoi c'est du et comment l'éviter ? tant pis pour le frame rate mais il faut que je puisse visualiser une image non altérée.

par contre apres un essai tout simple avec scanline au lieu d'appels a pixels[x,y], j'ai constater une forte degradations des performances : je veux dire par la que la fenetre dans le thread principale était "bloquée" a de nombreuses reprises, comme si la boucle etait faite dans le thread principal et non dans un thread séparé... il doit me manquer des infos, mais dans le forum en tapant scanline je n'ai pas trouvé tellement de littératures si vous avez un lien ca m'aiderait bien

il serait plus simple de poster une partie de ton code.

ceci dit, tu seras peut-être intéressé par une approche qui utilise un simple tableau de pixels

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
 
const
  IMAGE_WIDTH  = 256;
  IMAGE_HEIGHT = 256;
var
  pixels: array[0..IMAGE_WIDTH - 1, 0..IMAGE_HEIGHT - 1] of TColor;
 
procedure TForm1.FormCreate(Sender: TObject);
var
  x, y: Integer;
begin
  for x := 0 to IMAGE_WIDTH - 1 do
    for y := 0 to IMAGE_HEIGHT - 1 do
      pixels[x, y] := (x + y) or ((x - y) shl 8 ) or ((x + x) shl 16);
end;
 
procedure TForm1.FormPaint(Sender: TObject);
var
  BitsInfos: TBitmapInfo;
begin
  FillChar(BitsInfos, SizeOf(BitsInfos), 0);
  with BitsInfos do
  begin
    with bmiHeader do
    begin
      biSize          := 40;
      biWidth         := IMAGE_WIDTH;
      biHeight        := IMAGE_HEIGHT;
      biPlanes        := 1;
      biBitCount      := 32;
      biCompression   := BI_RGB;
    end;
  end;
  SetDIBitsToDevice(
    Canvas.Handle,
    10, 10, IMAGE_WIDTH, IMAGE_HEIGHT,
    0, 0, 0, IMAGE_HEIGHT,
    @pixels,
    BitsInfos,
    0
  );
end;

SetDIBitsToDevice permet de définir les rectangles source et destination, et tu peux aussi utiliser StretchDIBitsToDevice pour étirer l'image au besoin.

EDIT: un petit article sur le sujet

[niocco]

Cette instance de TTempMap devrait être une copie à usage unique du thread secondaire. Il ne faut pas espérer qu'il traite correctement cette donnée si la tâche principale la modifie constamment



Scanline n'est qu'un pointeur sur le premier pixel d'une image de résolution connue. Pixels[] est une fonction beaucoup plus complexe qui permet de faire abstraction de la résolution. Du 8, 16 ,24 ou 32 bits seront gérés de la même façon dans l'application, mais au prix de conversions non négligeables. Dans ton code et si Scanline est correctement traité, Synchronize est appelé beaucoup plus fréquemment et par conséquent... le thread principal bloqué plus souvent

Le mieux est toujours d'avoir un bitmap en traitement pendant qu'un deuxième est affiché. Le thread secondaire doit simplement annoncer qu'une nouvelle image est prête, mais pas s'occuper de son affichage.

merci pour ces conseils. j'ai modifier le code pour que le bmp soit local au thread, il y a juste une maj de pointeur en fin de traitement pour afficher le bmp et le traitement reprends sur un bmp interne. pareil pour la tempmap, on travaille sur une copie.

par contre, je n'utilise jamais synchronize. est ce vraiment un probleme ?

du coup pourquoi scanline bloque t il ma fenetre ? je mets meme un sleep 500 dans la boucle, ca ne résoud pas le probleme....

revoici le code du thread :

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
 
unit UPaintThread;
 
interface
 
uses sysutils, windows, classes, graphics, UTempMap, ULifeUtils;
 
type TPaintThread = class( TThread )
 
  public
    fps: integer;
    internalImage: graphics.TBitmap;
    constructor create( width, height: integer; m: TTempMap );
    function getBitmap(): graphics.TBitmap;
    procedure setTempMap( m: TTempMap );
  protected
    image: graphics.TBitmap;
    map: TTempMap;
    procedure Execute; override;
end;
 
implementation
 
uses ULifeRenderer, DateUtils;
 
{ TPaintThread }
 
constructor TPaintThread.create(width, height: integer; m: TTempMap);
begin
  inherited create( true );
 
  // draws on a internal bitmap
  internalImage := graphics.TBitmap.create;
  internalImage.Width := width;
  internalImage.Height := height;
 
  // uses a local copy of the tempmap
  map := TTempMap.create( m );
  fps := 0;
  suspended := false;
end;
 
{
procedure TPaintThread.execute;
var
  i, j: integer;
  P : PByteArray;
  c: TColor;
begin
    inherited;
    bmp.canvas.Pen.Style := psSolid;
    bmp.canvas.Pen.Mode := pmCopy;
    bmp.Canvas.Brush.Style := bsSolid;
 
    while not Terminated do
    begin
      bmp.canvas.lock;
      for j := 0 to Map.height - 1 do
      begin
        P := bmp.ScanLine[j];
        for i := 0 to Map.width - 1 do
        begin
          c := TempToColor( Map.Temps[i,j], Map.defaultTemperature, Map.maxTemp, Map.minTemp );
          // bmp.Canvas.Pixels[i,j] := c;
          P[i] := c;
        end;
      end;
      bmp.canvas.unlock;
      sleep( 500 );
    end;
end;
}
 
procedure TPaintThread.Execute;
var
  i, j : integer;
  c: Tcolor;
  nbFrame: integer;
  startedat: TDateTime;
  ElapsedTime: int64;
  P : PByteArray;
begin
    inherited;
    nbFrame := 0;
    startedat := now;
    internalImage.canvas.Pen.Style := psClear;
    internalImage.canvas.Pen.Mode := pmcopy;
    internalImage.Canvas.Brush.Style := bsSolid;
    internalImage.Canvas.Pen.Color := clwhite;
    internalImage.Canvas.brush.Color := clwhite;
    c := clBlack;
 
    while not Terminated do
    begin
      internalImage.canvas.lock;
 
      // pixel map access
      {
      for j := 0 to Map.height - 1 do
      begin
        for i := 0 to Map.width - 1 do
        begin
          if map.lock = false
            then c := TempToColor( Map.Temps[i,j], Map.defaultTemperature, Map.maxTemp, Map.minTemp );
          internalImage.Canvas.Pixels[i,j] := c;
        end;
      end;
      }
 
      // scanline bitmap access
      for j := 0 to Map.height - 1 do
      begin
        P := internalImage.ScanLine[j];
        for i := 0 to Map.width - 1 do
        begin
          c := TempToColor( Map.Temps[i,j], Map.defaultTemperature, Map.maxTemp, Map.minTemp );
          P[i] := c;
        end;
      end;
 
      // fp2s counter
      ElapsedTime := MilliSecondsBetween( now, startedat );
      if ElapsedTime >= 1000
      then
      begin
        fps := nbFrame;
//        nbframe := 0;
        startedat := now;
      end
      else
      begin
        nbframe := nbFrame + 1;
      end;
 
 
      internalImage.canvas.unlock;
      image := internalImage;
      sleep( 500 );
    end;
end;
 
 
function TPaintThread.getBitmap: graphics.TBitmap;
begin
  result := image;
end;
 
procedure TPaintThread.setTempMap(m: TTempMap);
begin
  map := m;
end;
 
end.

[Andnotor]

Canvas.Lock est une synchronisation et puisque la tâche principale accède à ce même canvas (TPaintThread.GetBitmap)...

Il faut vraiment travailler avec deux bitmaps :

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
type
  TPaintImages = array[boolean] of TBitmap;
 
  TPaintThread = class(TThread)
  private
    Wnd         :hWnd;
    Map         :TTempMap;
    Images      :TPaintImages;
    FlipFlop    :boolean;
    NewMap      :boolean;
    Lock        :TCriticalSection;
 
    function    GetImage :TBitmap;
 
  protected
    procedure   Execute; override;
 
  public
    property    Image :TBitmap read GetImage;
 
    procedure   SetMap(aMap :TTempMap);
    constructor Create(aWnd :hWnd; aWidth, aHeight :integer);
    destructor  Destroy; override;
  end;
 
Const
  WM_IMAGEREADY = WM_USER;
 
implementation
 
{ TPaintThread }
 
constructor TPaintThread.Create(aWnd :hWnd; aWidth, aHeight: integer);
begin
  inherited Create(TRUE);
 
  Wnd := aWnd;
 
  Images[FALSE]:= TBitmap.Create;
  Images[FALSE].SetSize(aWidth, aHeight);
 
  Images[TRUE] := TBitmap.Create;
  Images[TRUE].SetSize(aWidth, aHeight);
 
  Lock := TCriticalSection.Create;
 
  NewMap   := FALSE;
  FlipFlop := FALSE;
 
  Resume;
end;
 
destructor TPaintThread.Destroy;
begin
  Lock.Free;
  Images[FALSE].Free;
  Images[TRUE].Free;
 
  inherited;
end;
 
procedure TPaintThread.Execute;
var
  x :integer;
  y :integer;
  p :PByteArray;
  M :TTempMap;
 
begin
  while not Terminated do
    //Nouvelle map ?
    if NewMap then
    begin
      NewMap := FALSE;
 
      //Copie locale synchronisée
      Lock.Acquire;
      M := TTempMap.Create(Map);
      Lock.Release;
 
      //Traitement
      for y := 0 to M.Height -1 do
      begin
        P := Images[not FlipFlop].ScanLine[y];
 
        for x := 0 to M.Width -1 do
          P[x] := TempToColor(M.Temps[x,y], M.defaultTemperature, M.maxTemp, M.minTemp);
      end;
 
      //Changement d'image
      FlipFlop := not FlipFlop;
 
      //Notification
      PostMessage(Wnd, WM_IMAGEREADY, 0, 0);
    end
    else Sleep(10);
end;
 
function TPaintThread.GetImage: TBitmap;
begin
  Result := Images[FlipFlop];
end;
 
procedure TPaintThread.SetMap(aMap: TTempMap);
begin
  Lock.Acquire;
  Map := TTempMap.Create(aMap);
  Lock.Release;
 
  NewMap := TRUE;
end;

La fiche principale :

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
type
  TForm1 = class(TForm)
    procedure FormPaint(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    Thread :TPaintThread;
  protected
    procedure WMImageReady(var Message :TMessage); message WM_IMAGEREADY;
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  Thread := TPaintThread.Create(Handle, 100, 100);
end;
 
procedure TForm1.FormDestroy(Sender: TObject);
begin
  Thread.Free;
end;
 
procedure TForm1.FormPaint(Sender: TObject);
begin
  Canvas.Draw(0, 0, Thread.Image);
end;
 
procedure TForm1.WMImageReady(var Message: TMessage);
begin
  Invalidate;
end;

Il y a encore une erreur à corriger : tu créais internalImage sans en modifier la résolution (donc 24 bits) mais utilisais un PByteArray sur Scanline. Ça ne va traiter que le premier tiers de l'image

[niocco]

ah ouais quand même, j'avais donc tout ca de mal fait^^

merci pour ton code il est bien joli, et me permet de mieux comprendre l'usage d'une section critique.

quand j'utilisais la methode scanline, mon bitmap restais toujours vide. c'est du a ce probleme de résolution dont tu parle ? comment changer la résolution du bitmap ? surtout quelle est la bonne résolution ? celle actuelement utilisée par windows ?

[Andnotor]

Celle qui pose le moins de problème est le 32 bits (Bitmap.PixelFormat := pf32bit;) en utilisant un pointeur de type PRGBQuadArray :

Code :

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

1
2
3
type
  PRGBQuadArray = ^TRGBQuadArray;
  TRGBQuadArray = array [0..0] of TRGBQuad;

Il faudra peut-être modifier TempToColor...

[niocco]

ok je vais voir de coté....
pour info une couleur sur 3 octet ( type 255, 0, 0 pour le rouge ) se converti comment en couleur sur 4 ( 32 bits ) ?

[Paul TOTH]

ok je vais voir de coté....
pour info une couleur sur 3 octet ( type 255, 0, 0 pour le rouge ) se converti comment en couleur sur 4 ( 32 bits ) ?

le 4ième octet c'est le canal alpha, utilisé (ou pas) pour la transparence