Discussion :

[ChPr]

Bonjour à toutes et à tous,

Dans le développement de mon application GPS sur un Raspberry PI 3B, je me trouve confronté à un problème de durée d'exécution des tâches graphiques.

BeanzMaster m'avait suggéré d'essayer OpenGL.

Apparemment, OpenGL est actif sur mon Raspberry Pi 3B (avec stretch) car j'ai exécuté avec succès un des exemples (un cube qui tourne).

Pour autant, je me pose deux questions :

- la faisabilité,
- le gain de temps d'exécution graphique obtenu.

Pour la faisabilité, est-il possible de réaliser l'équivalent de ce qui suit :

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
 
     begin // Chargement des tuiles
       for i:= 0 to 4 do
         for j:= 0 to 4 do
           with Tuile do
           begin     {Chargement d'un panel de 25 cartes de 256 x 256 pixels²}
             NomTuile:= 'Cartes'+SepRep+Nom+IntToStr(Zoom)+SepRep+IntToStr(OSMLon+i-2)+SepRep+IntToStr(OSMLat+j-2)+'.jpg';
             if FileExists(NomTuile) then
             begin
               bmpTuile.LoadFromFile(NomTuile);
               bmpCarte.CanvasBGRA.CopyRect(Rect(DimTuile*i, DimTuile*j, DimTuile*(i+1), DimTuile*(j+1)), bmpTuile, Rect(0, 0, DimTuile, DimTuile));
             end;
           end;
     end;
 
procedure TAffCarte.PaintBoxPaint(Sender: TObject); // Rafraichissement de l'affichage
var
  i: Integer;
begin
  try
    if NbPtTrace > 1 then
      with bmpCarte do
        DrawLineAntialias(PtsTrace[NbPtTrace-2].X, PtsTrace[NbPtTrace-2].Y, PtsTrace[NbPtTrace-1].X, PtsTrace[NbPtTrace-1].Y, $FF0000, 1); // Tracé d'un segment de ligne
    bmpAff := TBGRABitmap.Create(DimCarte, DimCarte, BGRAWhite);
    bmpAff.PutImageAngle(Dec0.X-Depl.X, Dec0.Y-Depl.Y, bmpCarte, CapDeg,
         DemiCarte.X-(Dec0.X-Depl.X), DemiCarte.Y-(Dec0.Y-Depl.Y), $FF, True, False); // Déplacement et rotation
    BGRAReplace(bmpAff, bmpAff.Resample(Round(DimCarte*kZoom), Round(DimCarte*kZoom), rmSimpleStretch)); //Zoom
    CentreAff.X:= Round(DemiCarte.X*kZoom);
    CentreAff.Y:= Round(DemiCarte.Y*kZoom);
    HG.X:= Round((1-kZoom)*(DemiCarte.X))-128;
    HG.Y:= Round((1-kZoom)*(DemiCarte.Y))-340;
    Aff_Infos_GPS(CentreAff.X, CentreAff.Y+260, TxtGPS, bmpAff, clInfPos, CSSLightYellow); // Affichage d'un texte
    bmpAff.PutImage(CentreAff.X-32, CentreAff.Y-32, BmpCible, dmSetExceptTransparent, $FF); // Affichage d'une icône (un cible ici)
    bmpAff.Draw(PaintBox.Canvas, HG.X, HG.Y, False); // Trace la carte avec ses déplacements, zoom et rotation
    bmpAff.Destroy;
  except
    bmpAff.Destroy;
  end;
end;

De manière synoptique :

- Charger 25 tuiles de 256 x 256 pixels² dans un composant appelé "Carte" (1280 x 1280 pixels²) de type OpenGL (?)

-Affichage à récurrence rapide de (inférieur à 0.5 seconde serait bien) :

- Ajout d'un segment de ligne à la carte,
- Déplacement et rotation et effet de zoom d'une partie de cette carte,
- Ajout d'un texte (avec transparence),
- Ajout d'une cible,
- Affichage du tout.

Voilà ce que ça donne avec BGRABitmap.



Et maintenant, quel gain de temps espérer par rapport à BGRAbitmap ?

Cordialement.

Pierre