Utilisation du "clipping"

Bonjour à toutes et à tous,

Dans mon application GPS que je développe, j'ai un bitmap de 1280 x 1280 pixels² que je peux, par zoom amener à 2560 x 2560 pixels². Mais, après déplacements, rotations et zoom avec la bibliothèque TBGRABitmap, je n'en visualise qu'une partie de 1024 x 600 pixels².

La question que je me pose est : gagnerais-je du temps d'exécution en utilisant des fonctions de clipping ?

NOTA : je n'ai jamais joué avec ce genre de fonctions. En existe-t-il avec la bibliothèque TBGRABitmap et connaissez-vous un lien expliquant ce mode de fonctionnement/utilisation.

Cordialement.

Pierre

Bonjour ! Pas trop bien compris votre question. Quelle est l'opération qui pose problème exactement ? Que voulez-vous faire exactement ?

Je cherche simplement à faire en sorte que la suite d'opérations que j'exécute soit la plus rapide possible.

Celle qui prend le plus de temps est "PutImageAngle", environ 350 mS. Elle agit sur un bitmap de 1280 x 1280 pixels² :

Code:

---

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

procedure TAffCarte.PaintBoxPaint(Sender: TObject); // Rafraichissement de l'affichage var CentreAff, BordAff: TPoint; T1, T2: TDateTime; begin try LBmp := TBGRABitmap.Create(DimCarte, DimCarte, BGRAWhite); // LBmp.PutImage(Dec0.X-Depl.X, Dec0.Y-Depl.Y, bmpCarte, dmSet, 255); // Pas de rotation LBmp.PutImageAngle(Dec0.X-Depl.X, Dec0.Y-Depl.Y, bmpCarte, tckbAngle.Position, DemiCarte.X-(Dec0.X-Depl.X), DemiCarte.Y-(Dec0.Y-Depl.Y), $FF, DecalApresRot, False); // Déplacement et rotation BGRAReplace(LBmp, LBmp.Resample(Round(DimCarte*kZoom), Round(DimCarte*kZoom), rmSimpleStretch)); // LBmp:= TBGRABitmap(SimpleStretch(LBmp, Round(DimCarte*kZoom), Round(DimCarte*kZoom))); CentreAff.X:= Round(DemiCarte.X*kZoom); CentreAff.Y:= Round(DemiCarte.Y*kZoom); LBmp.DrawLine(CentreAff.X, 0, CentreAff.X, Round(DimCarte*kZoom), $FF, true, dmDrawWithTransparency); LBmp.DrawLine(0, CentreAff.Y, Round(DimCarte*kZoom), CentreAff.Y, $FF, true, dmDrawWithTransparency); HG.X:= Round((1-kZoom)*(DemiCarte.X))-128; HG.Y:= Round((1-kZoom)*(DemiCarte.Y))-340; LBmp.Draw(PaintBox.Canvas, HG.X, HG.Y, False); // Trace la carte avec ses déplacements, zoom et rotation LBmp.Destroy; except LBmp.Destroy; end; Mem:= GetHeapStatus; Edit5.Text:= IntToStr(Mem.TotalFree); end;

---

Ne connaissant pas les fonctions de clipping, je me disais que cela pouvait peut-être aider.

Cordialement.

Pierre

D'accord, je comprends mieux pourquoi ça prend du temps. Je donne ma langue au chat en ce qui concerne le clipping.

salut

de plus l'exemple n'utilise pas de callback pour mettre a jour l’écran ce qui pourrais être très efficace

si j'ai bien compris ton problème

1°) Tu reçois des données de ton GPS
2°) a l'aide des données tu affiche la carte correspondante (Carte de fond)

3°) Tans que tu reçois des données du GPS Tu met a jours la zone et / ou la carte selon tes déplacements

on vois bien que la mises a jour de ton ecran est conditionné par l'arrivé ou non des donnée de ton GPS
il est donc impératif de "threader" tes datas et pas ton affichage

Citation:

---

Envoyé par anapurna

... il est donc impératif de "threader" tes datas et pas ton affichage

---

Si je traduis cette phrase dans mon langage, est-ce que cela veut dire :

- Le traitement des images se fait dans le thread principal, c'est-à-dire l'application graphique principale,

- Le traitement des données se fait dans le thread secondaire.

Oui, Non ?

Cordialement.

Pierre

salut

dis comme cela oui

Salut

Pour ton histoire de clipping c'est a toi de calculer la position haut/gauche de la partie que tu veux afficher.
C'est comme une fenêtre que tu déplaces pour ne traiter que ce qui est visible

Pièce jointe 481707

Tu peux même aller plus loin avec le zoom en calculant le ratio Facteur Zoom par rapport à l'image --> Dimension affichage, pour ne zoomer que la partie visible

Pièce jointe 481711

Les informations à traiter seront donc moins importantes et ces opérations devraient permettre une animation plus fluide. Le coup de cette opération est l'utilisation d'un ou deux Bitmaps supplémentaire "tampon" en mémoire.

A+

Dans la suite des opérations que j'effectue, celle qui prend le plus de temps est la première : "PutImageAngle" : 350 mS

Le reste, Zoom (Resample) et Draw ne prennent que 50 mS au maximum.

Le principe de mon graphisme est le suivant : pour être sûr d'avoir une visualisation sur un écran de 1024 x 600 (soit 1186 pixels de diagonale) avec une rotation qui peut aller de 0 à 360°, il me faut un bitmap de 1280 x 1280 pixels².

Ce bitmap est composé de 5 x 5 dalles de 256 x 256 pixels². Je remplace ces dalles à chaque fois que je me déplace d'un peu mois que les dimensions d'une dalle.

Peut-être y a-t-il un autre type d'enchaînement à faire ?

Cordialement.

Pierre

Re-Salut

Pour mettre a jour tes dalles,tu pourrais passer par l'utilisation d'un ou plusieurs threads comme tu le suggérais.

Sinon, pour optimiser l'affichage il faudrait passer par une gestion hardware des graphismes avec OpenGL par exemple. Mais je ne sais pas si le raspberry gère par défaut l'openGL ou si il faut l'activer et si tous les modèles le supporte.
Cela serait clairement plus fluide que de faire les opérations en "software" vue la taille des images que tu dois gérer.

@ BeanzMaster,

Merci pour ces propositions.

Pour le chargement des tuiles, cela prend 350 mS pour 25 tuiles. Leur changement n'est pas trop fréquents, environ toutes les minutes. Pour autant, je garde sous le coude le fait de pouvoir les précharger à l'aide d'un Thread;

Pour ce qui est de l'openGL, là, j'en avais fait une expérience (bonne) il y a au moins un quart de siècle :ptdr:, j'ai complètement oublié ... mais faudra que j'y pense.

Cordialement.

Pierre