Discussion :

[ChPr]

Bonjour à toutes et à tous,

Dans mon programme GPS, au fur et à mesure que je me déplace (via les données du GPS ou avec la souris sur l'écran), je dois rafraichir ma carte avec de nouvelles tuiles.

Pour ce faire, lorsque que j'arrive à un certain pourcentage du bord de la dernière tuile, je déclenche le chargement et placement de nouvelles tuiles.

Probléme : de temps à autre, lors de ce changement, les tuiles que j'obtiens ne sont pas les bonnes, comme si un évènement s'était produit au cours de ce changement.

Ci-après un morceau de ce que je fais :

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
  3: begin  // Diminution de la latitude
       for j:= 1 to 4 do
         BmpCarte.CanvasBGRA.CopyRect(Rect(0, DimTuile*(j-1), DimTuile*5, DimTuile*j), BmpCarte, Rect(0, DimTuile*j, DimTuile*5, DimTuile*(j+1)));
       for i:= 0 to 4 do
         with Tuile do
         begin     {Chargement d'un panel de 4 cartes de 256 x 256 pixels²}
           NomCarte:= Fch_Tuile(OSMLat+2, OSMLon+i-2, Tuile);
           if NomCarte = '' then
             BmpCarte.CanvasBGRA.CopyRect(Rect(DimTuile*i, DimTuile*4, DimTuile*(i+1), DimTuile*5), BmpVide, Rect(0, 0, DimTuile, DimTuile))
           else
           begin
             NomTuile:= 'Cartes'+SepRep+NomCarte+IntToStr(Zoom)+SepRep+IntToStr(OSMLon+i-2)+SepRep+IntToStr(OSMLat+2)+'.jpg';
             if FileExists(NomTuile) then
             begin
               BmpTuile.LoadFromFile(NomTuile);
               BmpCarte.CanvasBGRA.CopyRect(Rect(DimTuile*i, DimTuile*4, DimTuile*(i+1), DimTuile*5), BmpTuile, Rect(0, 0, DimTuile, DimTuile));
             end;
           end;
         end;
       Decal.Y:= Decal.Y-256;
       Depl.Y:= Depl.Y-256;
     end;

J'ai essayé d'y remédier avec des sections critiques (peut-être mal employées) mais cela n'a rien amélioré.

Ce qu'il me faudrait (je pense), c'est un drapeau, une procédure, ... qui ferait en sorte que le tronçon de code que j'exécute ne soit pas perturbé, coupé par un évènement quelconque.

Si vous avez des idées ...

Cordialement.

Pierre

[BeanzMaster]

Bonjour à toutes et à tous,

Dans mon programme GPS, au fur et à mesure que je me déplace (via les données du GPS ou avec la souris sur l'écran), je dois rafraichir ma carte avec de nouvelles tuiles.

Pour ce faire, lorsque que j'arrive à un certain pourcentage du bord de la dernière tuile, je déclenche le chargement et placement de nouvelles tuiles.

Probléme : de temps à autre, lors de ce changement, les tuiles que j'obtiens ne sont pas les bonnes, comme si un évènement s'était produit au cours de ce changement.

Ci-après un morceau de ce que je fais :

...

J'ai essayé d'y remédier avec des sections critiques (peut-être mal employées) mais cela n'a rien amélioré.

Ce qu'il me faudrait (je pense), c'est un drapeau, une procédure, ... qui ferait en sorte que le tronçon de code que j'exécute ne soit pas perturbé, coupé par un évènement quelconque.

Si vous avez des idées ...

Cordialement.

Pierre

Salut, les sections critique c'est pour les thread donc le mieux serait de créer un Thread que tu lancerai au moment adéquate et qui se chargerai de charger tes tuiles en tâche de fond. Suffirait juste d'un "drapeau" pour savoir quand le processus est terminé afin de bloquer temporairement le déplacement jusqu'à une certaine limite

A = Ancienne tuile
N = Nouvelle Tuile (noire jusqu'à la fin du chargement)
P = Position GPS / tuile en cours

AANNN...
APNNN...
AANNN...

A+
Jérôme

[der§en]

J'ai exploité pour un besoin totalement personnel, un système a base de pool de Threads (sous le framework firemonkey de Delphi) qui fonctionne très bien pour afficher des fractales dans un système de tuiles (avec des niveaux de zooms):

https://parnassus.co/a-firemonkey-cl...brot-data-set/

Les sources son proposé, et je pense que l'on devrais pouvoir les adapter a Lazarus...

[Guesset]

Bonjour,

La portion de code est un peu succincte mais je me demande si nous n'avons pas ici un problème de cascade. Le code est activé par un déplacement (hypothèse) et il provoque lui même un déplacement (à la fin de l'extrait). Normalement le déplacement induit a pour but de recentrer très approximativement le curseur. Mais le pas de déplacement est fixe (dimension d'une dalle), alors que se passe t'il si ce pas s'avère insuffisant ?

Ce n'est qu'une piste mais ce genre de problème est fréquent avec les chaînes d'événements.

Bonne chance.

[ChPr]

J'ai placé des points de log à chaque changement de tuile et apparemment, tout se passe bien.

J'ai observé que si je me déplace doucement, il n'y a pas de problème.

Les problèmes semblent arriver lorsque je demande brusquement un grand déplacement.

Il faut que j'arrive à quantifier cela en rapport à la dimension des tuiles.

Il me semble que si j'arrivais à scinder un brusque (ou grand) déplacement de la souris en plusieurs petits pas, cela résoudrait (peut-être) le problème.

Il faut donc que je réalise une procédure qui fasse ce découpage ...

Cordialement.

Pierre

[Guesset]

Bonjour,

Il est possible de voir un peu plus largement le code ? Est-ce une fonction/procédure ou un gestionnaire d'événement ? Quand il modifie la position en fin de traitement, y a t'il une vérification que le mouvement généré est suffisant pour ramener le curseur dans la zone affichée ? Que se passe-t'il si ce n'est pas le cas ?

Salutations

[ChPr]

... Il est possible de voir un peu plus largement le code ? ...

Ce n'est pas que je ne veuille pas, mais le code est très long et met en jeu plusieurs unités qui, sans avoir une vue totale de l'application, reste assez incompréhensibles à moins de les décrire sur des dizaines de pages ...

La partie que je vous ai montrée concerne le choix et le chargement des tuiles. La procédure qui est présentée ci-après est celle qui met en œuvre les déplacements.

Cette procédure était avant dans l'évènement "OnMouseMove" Elle est maintenant déclenchée par l'évènement "OnIdle". Pourquoi ?

Je me suis aperçu que, si on déplaçait rapidement la souris d'un point à un autre et que l'on ne bouge plus de ce dernier point, du fait de la longueur du traitement à effectuer, l'évènement "OnMouseMove" se déclenchait rapidement, pratiquement dès le début du mouvement, mais n'était plus redéclenché pour le reste de la trajectoire. De ce fait, la procédure "MonAffichageMouseMove" n'était pas mise à jour du point final ... que je ne pouvais donc atteindre.

L'évènement OnIdle se déclenchant dès qu'il n'y a plus rien à faire, la dernière position de mon curseur est mise à jour dès ce moment ... et je peux donc l'atteindre.

Néanmoins, ceci n'est que du détail de cuisine interne.

Je me suis aperçu que si je scindais le parcours en petit tronçons, la fréquence de mauvais placement de tuiles était grandement diminuée (sans pour autant devenir nulle ). Dans la procédure qui suit, est présenté ce découpage.

Toutefois, je n'ai pas réussi à mettre en évidence la cause du problème.

NOTA : le problème est le même que je sois sur mon PC avec Windows XP ou sur mon Raspberry Pi 3B+ sous Raspbian "Stretch".

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
procedure TAffCarte.Loisir(Sender: TObject; var Done: Boolean);
{Cette procédure est déclenchée par l'évènement "OnIdle"}
{Il semble que sur l'écran tactile 7" de mon Raspberry, les premières données de
 "OnMove" obtenues par toucher de l'écran ne soient pas correctes. Un petit
 compteur permet de ne pas les prendre en compte.}
var
  Da, Xa, Ya: Extended;
begin
  GetCursorPos(PosS);
  PosS:= ScreenToClient(PosS); // Position courante du curseur
  if SourisDown then
  begin
    Xa:= PosS.X*cosCap+PosS.Y*sinCap;
    Ya:= PosS.Y*cosCap-PosS.X*sinCap;
{}   Write(Flog,IntToStr(XXX)+'   Xa  '+IntToStr(PosS.X)+'   Ya  '+IntToStr(PosS.Y));
 
    Depl.X:= (CurPos0.X-Xa)/kZoom; // Depl = déplacement de la souris en pixels
    Depl.Y:= (CurPos0.Y-Ya)/kZoom;
{}    Write(Flog, '  Depl.X  '+IntToStr(Round(Depl.X))+'  Depl.Y  '+IntToStr(Round(Depl.Y)));
 
    Da:= Sqrt(Depl.X*Depl.X+Depl.Y*Depl.Y); // Taille du déplacement à effectuer
{}    Write(FLog, '  Da  '+IntToStr(Round(Da)) );
    if Da > DeplMax then  // Si le déplcement est trp grand ...
    begin  // ... on le scinde en plusieurs tronçons consécutifs
      Depl.X:= Depl.X*DeplMax/Da;
      Depl.Y:= Depl.Y*DeplMax/Da;
    end;
{}    Write(Flog, '  Depl.X  '+IntToStr(Round(Depl.X))+'  Depl.Y  '+IntToStr(Round(Depl.Y)));
    if CmptDepl > 1 then
    begin
      TotDepl.X:= TotDepl.X+Depl.X;
      TotDepl.Y:= TotDepl.Y+Depl.Y;
{}      Write(Flog, '  TotDepl.X  '+IntToStr(Round(TotDepl.X))+'  TotDepl.Y  '+IntToStr(Round(TotDepl.Y)));
      if Da > DeplMax then  // Si déplacement tronçonné, mise à jour partielle de la position du curseur
      begin
        CurPos0.X:= CurPos0.X-Depl.X*kZoom;
        CurPos0.Y:= CurPos0.Y-Depl.Y*kZoom;
      end
      else
      begin  // sinon la position du curseur est amenée directement à la valeur finale.
        CurPos0.X:= Xa;
        CurPos0.Y:= Ya;
      end;
{}      Write(Flog, '  CurPos0.X  '+IntToStr(Round(CurPos0.X))+'  CurPos0.Y  '+IntToStr(Round(CurPos0.Y)));
      Longitude:= LonTuileG+(DemiTuile+TotDepl.X)*(LonTuileD-LonTuileG)/DimTuile;
      if Longitude > 180 then
        Longitude:= Longitude-360
      else if Longitude < -180 then
        Longitude:= Longitude+360;
      Latitude:= LatTuileB+(DemiTuile-TotDepl.Y)*(LatTuileH-LatTuileB)/DimTuile;
      if MajAff then
      begin
        MaJ_Carte(PointF(TotDepl.X, TotDepl.Y)); // Choix et chargement des nouvelles tuiles à afficher
        clInfPos:= VGABlue;
        TxtGPS:= Choix_Aff_Coord(Latitude, Longitude, TypeCoord);
        ZoneAff.DoOnPaint; // Rafraichement de l'écran
{}        Inc(XXX);
      end;
    end;
{}    WriteLn(FLog);
    Inc(CmptDepl);
  end;
  Done:= True;
end;

Cordialement.

Pierre.

[anapurna]

Salut

Quand tu découpes ton déplacement en tronçons il ne te manque pas une boucle pour aller jusqu'au dernier tronçon ?

@+ Phil

[ChPr]

... quand tu découpes ton déplacement en tronçons
il te manque pas une boucle pour aller jusqu'au dernier tronçons ? ... l

Je vais jusqu'au bout. Qu'est-ce qui te fait dire ça ?

Cordialement.

Pierre

[ChPr]

Je n'arrive pas à mettre la main dessus. Il m'a semblé (aurais-je rêvé !) qu'il y existait une fonction qui permettait le blocage de toute instruction pendant qu'on faisait une traitement sur les bitmap ou équivalent. Un genre de Lock... unLock ...

Est-ce que cela vous dit quelque chose ?

Cordialement.

Pierre

[Guesset]

Bonjour,

BeginUpdate et EndUpdate sont peut être les fonctions recherchées, elles (dé)bloquent (normalement) l'actualisation de l'affichage du TImage correspondant au bitmap embarqué.

La fonction associée devrait également être appelée si la nouvelle position ne permet pas de garder la position curseur sur l'écran:

• à la fin de la précédente procédure (celle présentée lors du premier message) il est possible d'actualiser un flag, par exemple isOK, qui indiquerait si le déplacement est suffisant.
• dans le gestionnaire du OnIddle si ce flag est False alors on actualise indépendamment de tout mouvement de souris ou assimilé.

L'autre approche serait de calculer le dalles nécessaires quelque soit le déplacement et d'en déduire celles à charger. Mais cela change sensiblement le programme

Salutations

[ChPr]

... BeginUpdate et EndUpdate sont peut être les fonctions recherchées, elles (dé)bloquent (normalement) l'actualisation de l'affichage du TImage correspondant au bitmap embarqué. ...

BeginUpdate et EndUpdate sappliquent aux Bitmap mais pas aux TBGRABitmap. J'ai toutefois essayé avec un transtypage, mais cela n'a donné aucun résultat.

De même Lock et Unlock fonctionnent avec un TCanvas et ne fonctionnent pas ici.

... L'autre approche serait de calculer le dalles nécessaires quelque soit le déplacement et d'en déduire celles à charger. Mais cela change sensiblement le programme ...

C'est ce que fait mon programme, en fonction de la position à atteindre, il calcule quelles sont les dalles à charger.

Cordialement.

Pierre

[Guesset]

Bonjour,

Sauf erreur, le programme calcule le sens de déplacement (1 parmi 9 sans doute) et en déduit, en supposant un affichage de 3x3 dalles, une rangée de 3 dalles (ou 5 si c'est un déplacement vers un angle) à charger.

Je n'ai pas l'impression qu'il s'intéresse à l'amplitude du déplacement.

Or, par exemple, avec un déplacement vers la droite (en supposant un affichage de 3x3 dalles) il peut y avoir 3, 6 ou 9 dalles à changer selon l'amplitude. C'est en commençant par le calcul des dalles à afficher puis en comparant avec les dalles déjà chargées pour en déduire celles à charger que l'algorithme proposé fonctionne. Cette inversion de la séquence (mouvement -> dalles à afficher -> dalles à charger au lieu de mouvement -> dalles à charger -> dalles à afficher) permettrait de traiter plus facilement tout déplacement.

Mais peut être que la vision parcellaire m'induit en erreur.

Bon courage.

[ChPr]

... Sauf erreur, le programme calcule le sens de déplacement (1 parmi 9 sans doute) et en déduit, en supposant un affichage de 3x3 dalles, une rangée de 3 dalles (ou 5 si c'est un déplacement vers un angle) à charger. ...

Lorsque le déplacement reste à l'intérieur d'une tuile, c'est seulement le BmpCarte qui est déplacé à l'affichage.

Dés que j’atteins (à un seuil avec hystérésis près) le bord d'une tuile, Je considère qu'il faut tout faire bouger d'une tuile dans le sens du déplacement. Cela consiste à décaler d'une tuile toutes les tuiles restant en vue et de charger les nouvelles aux endroits devenus vides.

Je ne gère que quatre directions : gauche, droite, haut et bas ; je ne considère pas les déplacements à 45°

... Je n'ai pas l'impression qu'il s'intéresse à l'amplitude du déplacement. ...

Effectivement, je considère que le déplacement est toujours inférieur à la dimension d'une tuile. Raison pour laquelle, j'ai scindé les grands déplacements en plusieurs toujours plus petits qu'une tuile.

... Cette inversion de la séquence (mouvement -> dalles à afficher -> dalles à charger au lieu de mouvement -> dalles à charger -> dalles à afficher) permettrait de traiter plus facilement tout déplacement. ...

Je ne comprends pas cette distinction car, dans mon cas, dalles à charger = dalles à afficher.

Cordialement.

Pierre

[ChPr]

... Je ne gère que quatre directions : gauche, droite, haut et bas ; je ne considère pas les déplacements à 45° ...

A la réflexion, je me suis dit que le problème pouvait venir de là. J'ai donc complété la gestion aux angles ... pas mieux .

Cordialement.

Pierre

[Guesset]

Bonjour,

Si le découpage d"un déplacement est bien fait, il ne devrait y avoir de différence entre l'algorithme sue je propose et celui-ci.

Cependant l'usage d'une distance, Da:= Sqrt(Depl.X*Depl.X+Depl.Y*Depl.Y);, me rend un peu perplexe. Comme j'ai essayé de le montrer ci-après, un déplacement d'une même distance DA peut très bien sortir on rester à l'intérieur. Les axes X et Y doivent à mon avis être séparés.

Bon courage

[anapurna]

salut

j'ai commenté ton code
il me parait bien trop complexe juste pour déplacer une tuile

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
procedure TAffCarte.Loisir(Sender: TObject; var Done: Boolean);
{Cette procédure est déclenchée par l'évènement "OnIdle"}
{Il semble que sur l'écran tactile 7" de mon Raspberry, les premières données de
 "OnMove" obtenues par toucher de l'écran ne soient pas correctes. Un petit
 compteur permet de ne pas les prendre en compte.}
var
  Da, Xa, Ya: Extended;
begin
  GetCursorPos(PosS);
  PosS:= ScreenToClient(PosS); // Position courante du curseur
  
  if SourisDown then // Si  ouris down ;
  begin
    Xa:= PosS.X*cosCap+PosS.Y*sinCap; //cosCap et sinCap ?
    Ya:= PosS.Y*cosCap-PosS.X*sinCap; // 
    Write(Flog,IntToStr(XXX)+'   Xa  '+IntToStr(PosS.X)+'   Ya  '+IntToStr(PosS.Y));
 
    Depl.X:= (CurPos0.X-Xa)/kZoom;  //CurPos0,kZoom ?   // Depl = déplacement de la souris en pixels
    Depl.Y:= (CurPos0.Y-Ya)/kZoom;
    Write(Flog, '  Depl.X  '+IntToStr(Round(Depl.X))+'  Depl.Y  '+IntToStr(Round(Depl.Y)));
 
    Da:= Sqrt(Depl.X*Depl.X+Depl.Y*Depl.Y); // Le carrée du déplacement
    Write(FLog, '  Da  '+IntToStr(Round(Da)) );
	
    if Da > DeplMax then  // Si le déplcement est trp grand ... //  DeplMax?
    begin  // ... on le scinde en plusieurs tronçons consécutifs ?? c'est ou le consecutif ? 
      Depl.X:= Depl.X*DeplMax/Da; //=> DeplMax/Da * Depl.X => Coeff *Depl.X avec Coeff:= DeplMax/Da  
      Depl.Y:= Depl.Y*DeplMax/Da;//(CurPos0.Y-Ya)/kZoom * DeplMax/Da 
    end;
    Write(Flog, '  Depl.X  '+IntToStr(Round(Depl.X))+'  Depl.Y  '+IntToStr(Round(Depl.Y)));

    if CmptDepl > 1 then  //  CmptDepl ?
    begin
      TotDepl.X:= TotDepl.X+Depl.X;// TotDepl.X ? 
      TotDepl.Y:= TotDepl.Y+Depl.Y;// TotDepl.y ? 
      Write(Flog, '  TotDepl.X  '+IntToStr(Round(TotDepl.X))+'  TotDepl.Y  '+IntToStr(Round(TotDepl.Y)));
  
      if Da > DeplMax then  // Si déplacement tronçonné, mise à jour partielle de la position du curseur
      begin
        CurPos0.X:= CurPos0.X-Depl.X*kZoom; // on deplace d'un increment ? pourquoi * KZoom  il est deja dans  Depl  
        CurPos0.Y:= CurPos0.Y-Depl.Y*kZoom; // on deplace d'un increment
      end
      else
      begin  // sinon la position du curseur est amenée directement à la valeur finale.
        CurPos0.X:= Xa;
        CurPos0.Y:= Ya;
      end;
      Write(Flog, '  CurPos0.X  '+IntToStr(Round(CurPos0.X))+'  CurPos0.Y  '+IntToStr(Round(CurPos0.Y)));
	  
      Longitude:= LonTuileG+(DemiTuile+TotDepl.X)*(LonTuileD-LonTuileG)/DimTuile;
      
      if Longitude > 180 then
        Longitude:= Longitude-360
      else if Longitude < -180 then
        Longitude:= Longitude+360;
		
      Latitude:= LatTuileB+(DemiTuile-TotDepl.Y)*(LatTuileH-LatTuileB)/DimTuile;
      if MajAff then  // Comment est declenché  MajAff
      begin
        MaJ_Carte(PointF(TotDepl.X, TotDepl.Y)); // Choix et chargement des nouvelles tuiles à afficher
        clInfPos:= VGABlue;
        TxtGPS:= Choix_Aff_Coord(Latitude, Longitude, TypeCoord); //TypeCoord ???
        ZoneAff.DoOnPaint; // Rafraichement de l'écran
        Inc(XXX); // ????
      end;
    end;
    WriteLn(FLog);
    Inc(CmptDepl); // CmptDepl ???
  end;
  Done:= True;
end;

c'est quand même un sacre sac de nœud

[BeanzMaster]

Salut, ton problème me fait penser aux jeux de plateforme et à l'affichage des niveaux avec des tuiles et le déplacement du héros

J'ai quelques questions :

- Le mouvement de la souris c'est pour simuler le déplacer de ton véhicule, non ?
- La position courante devrait donc toujours être centrée sur l'écran (si je me souviens bien c'était le cas avec ton problème de rotation) ?
- Tes tuiles ne sont pas illimités tu connais combien tu en as, qu'elle la dimension maximal en tuile pour la hauteur et la largeur ?
- Combien de tuiles affiches tu à l'écran en même temps ?

Tu devrais envisager une approche de déplacement comme dans les jeux de ce type

A+

[wiwaxia]

Bonjour,

... Dans mon programme GPS, au fur et à mesure que je me déplace (via les données du GPS ou avec la souris sur l'écran), je dois rafraichir ma carte avec de nouvelles tuiles.

Pour ce faire, lorsque que j'arrive à un certain pourcentage du bord de la dernière tuile, je déclenche le chargement et placement de nouvelles tuiles.

Probléme : de temps à autre, lors de ce changement, les tuiles que j'obtiens ne sont pas les bonnes, comme si un évènement s'était produit au cours de ce changement ...

Les tuiles sont-elles prédéfinies, et de quelle manière ? Parce que si le quadrillage évoqué n'introduit pas de difficultés tant qu'on reste aux latitudes modérées, il n'en va pas de même lorsque l'on se rapproche des pôles: une partition du géoïde établie sur des angles conduit en effet à des zones de plus en plus étroites.
Ce qui est en cause, c'est le pavage de la sphère.

[ChPr]

... Les tuiles sont-elles prédéfinies, et de quelle manière ? ...

Oui, elles le sont. Elles sont au format OSM et donc, quelle que soient la latitude et la longitude, ce sont des bitmaps de 256 x 256 pixels².

Cordialement.

Pierre