Page 1 sur 1

Bizarrerie sinusoïdale !

Publié : ven. 30/janv./2009 4:07
par Huitbit
Hello,
Toujours pour mon p'tit utilitaire(voir "l'arc-en-ciel"), j'ai voulu moduler en fréquence un sinus :
fonction du type y=amplitude*sin(2*#pi*f(t)) avec f(t), fréquence variable

Ben voilà, essayez le code :
(courbe n°1 en haut, ce que j'ai obtenu 8O 8O 8O )
(courbe n°2 en bas, ce que je pensais obtenir)

Code : Tout sélectionner

;Bizarrerie du sinus modulé ?
;auteur Huitbit 
;PureBasic 4.30 (Windows - x86) 

#largeur_ecran=1024
#hauteur_ecran=768
#marge=12

;-données courbe n°1
x1_ancien.f=#marge
y1_ancien.f=#hauteur_ecran*0.25
frequence1.f=100

;-données courbe n°2
x2_ancien.f=#marge
y2_ancien.f=#hauteur_ecran*0.75
frequence2.f=100
x2_0=#marge
sym=1


frequence_echantillonnage.f=1000 

OpenWindow(0, 0, 0, #largeur_ecran, #hauteur_ecran, "Bizarre !", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
StartDrawing(WindowOutput(0))
  ;-dessin des écrans
Box(0,#hauteur_ecran*0.5,#largeur_ecran,#hauteur_ecran*0.5,RGB(0,0,0))
Box(0,0,#largeur_ecran,#hauteur_ecran*0.5-#marge,RGB(0,0,0))
    
;-tracé des courbes
For x=12 To 1000

  ;-courbe n°1 *******************************************************************************
  frequence1=(100-0.1*x)
 
  y1=#hauteur_ecran*0.25-120*Sin(2*#PI*frequence1*x/frequence_echantillonnage)
 
  LineXY(x1_ancien,y1_ancien,x,y1,RGB(255,0,0))
  x1_ancien=x
  y1_ancien=y1
 
  
  ;-courbe n°2 ********************************************************************************
  If x<x2_0+frequence_echantillonnage/frequence2*0.5
  
    y2=#hauteur_ecran*0.75-120*sym*Sin(2*#PI*frequence2*(x-x2_0)/frequence_echantillonnage)
 
  Else
    x2_0=x2_0+frequence_echantillonnage/frequence2*0.5
    frequence2=100-0.1*x2_0
    sym=-sym
  EndIf
  
  LineXY(x2_ancien,y2_ancien,x,y2,RGB(255,0,0))
  x2_ancien=x
  y2_ancien=y2
  
Next x

StopDrawing()   

Repeat : Until WaitWindowEvent() = #PB_Event_CloseWindow 
Pour les deux courbes, les fréquences diminuent (équation f=100-0.1*x) et pourtant, pour la courbe n°1, ce n'est pas le cas 8O.

Pour obtenir la courbe n°2, j'ai dû découper la courbe en demi-sinusoïdes et faire varier de manière discrète la fréquence.

Imaginez un son qui correspondrait à ces courbes:
courbe n°1 : un son aigu qui devient grave puis ...qui remonte dans les aigus
courbe n°2 un son aigu qui devient grave (ce que je souhaite!)

Il y a pas mal de phénomènes physiques avec les ondes (effet Doppler,diffraction, interférences, battements...etc).

Pour la courbe n°1 je ne vois pas d'équivalent physique.

Si quelqu'un a déjà vu ça (acoustique, traitement du signal, optique...), un petit article serait sympa !


Hasta la vista !

Publié : ven. 30/janv./2009 10:26
par Frenchy Pilou
Courbe n°1
Un pianiste qui fait ses gammes en partant de la partie droite de son piano ad libitum :lol:

Publié : ven. 30/janv./2009 10:39
par gildev
Ouais ben c'est pas avec mes 2/20 de moyenne en math que je vais vous aider... :oops:

Publié : ven. 30/janv./2009 14:59
par Huitbit
@Frenchy Pilou
Un pianiste
Plutôt un joueur de trombone :wink:
Le problème c'est que le joueur diminue et augmente la fréquence en changeant la taille du piston.

Ici, la fréquence imposée diminue mathématiquement (de ~100Hz à 0Hz)
2/20 de moyenne en math
8O Faut être doué pour faire ça :lol: :wink:

Hasta la vista!

Publié : ven. 30/janv./2009 15:18
par zaphod
bizarre,
pour que je vois quelque chose il faut que je mette la boucle de dessin dans la boucle d'évènements :

Code : Tout sélectionner

;Bizarrerie du sinus modulé ? 
;auteur Huitbit 
;PureBasic 4.30 (Windows - x86) 

#largeur_ecran=1024 
#hauteur_ecran=768 
#marge=12 

;-données courbe n°1 
x1_ancien.f=#marge 
y1_ancien.f=#hauteur_ecran*0.25 
frequence1.f=100 

;-données courbe n°2 
x2_ancien.f=#marge 
y2_ancien.f=#hauteur_ecran*0.75 
frequence2.f=100 
x2_0=#marge 
sym=1 


frequence_echantillonnage.f=1000 

OpenWindow(0, 0, 0, #largeur_ecran, #hauteur_ecran, "Bizarre !", #PB_Window_SystemMenu | #PB_Window_ScreenCentered) 


Repeat :

 event=WaitWindowEvent() 
;
 StartDrawing(WindowOutput(0)) 
  ;-dessin des écrans 
Box(0,#hauteur_ecran*0.5,#largeur_ecran,#hauteur_ecran*0.5,RGB(0,0,0)) 
Box(0,0,#largeur_ecran,#hauteur_ecran*0.5-#marge,RGB(0,0,0)) 
FrontColor(RGB(0,0,255))    
;-tracé des courbes 
For x=12 To 1000 

  ;-courbe n°1 ******************************************************************************* 
  frequence1=(100-0.1*x) 
  
  y1=#hauteur_ecran*0.25-120*Sin(2*#PI*frequence1*x/frequence_echantillonnage) 
  
  LineXY(x1_ancien,y1_ancien,x,y1,RGB(255,0,0)) 
  x1_ancien=x 
  y1_ancien=y1 
  
  
  ;-courbe n°2 ******************************************************************************** 
  If x<x2_0+frequence_echantillonnage/frequence2*0.5 
  
    y2=#hauteur_ecran*0.75-120*sym*Sin(2*#PI*frequence2*(x-x2_0)/frequence_echantillonnage) 
  
  Else 
    x2_0=x2_0+frequence_echantillonnage/frequence2*0.5 
    frequence2=100-0.1*x2_0 
    sym=-sym 
  EndIf 
  
  LineXY(x2_ancien,y2_ancien,x,y2,RGB(255,0,0)) 
  x2_ancien=x 
  y2_ancien=y2 
  
Next x 

StopDrawing()    
 
 ;
 If event= #PB_Event_CloseWindow 
 Break
 EndIf
 ForEver
z@ph0d

Publié : ven. 30/janv./2009 15:45
par Huitbit
@zaphod
Bizarre :?
Ton code ne fonctionne pas normalement chez moi !
Mon code vient de l'aide "box" de pb

Code : Tout sélectionner

 ; Plusieurs rectangles de couleur aléatoire
  Largeur=200
  Hauteur=150
  If OpenWindow(0, 0, 0, Largeur, Hauteur, "Rectangles", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
    If StartDrawing(WindowOutput(0))
      y = 0
      #StepX = 10
      StepY = Round(#StepX*Hauteur/Largeur, 0)
      For x = 0 To Largeur/2-5 Step #StepX
        Box(x, y, Largeur-2*x, Hauteur-2*y ,RGB(Random(255),Random(255),Random(255)))
        y + StepY     ; C'est équivalent à y = y + StepY
      Next x
      StopDrawing()   ; C'est absolument indispensable quand les opérations de dessins sont terminées !!! Ne jamais l'oublier !
    EndIf
    
    Repeat : Until WaitWindowEvent() = #PB_Event_CloseWindow
  EndIf
Vérifie avec les exemples de l'aide de pb !

Hasta la vista !

Publié : ven. 30/janv./2009 16:08
par Le Soldat Inconnu
comme ça ?

Code : Tout sélectionner

;Bizarrerie du sinus modulé ? 
;auteur Huitbit 
;PureBasic 4.30 (Windows - x86) 

#largeur_ecran=1024 
#hauteur_ecran=768 
#marge=12 

;-données courbe n°1 
x1_ancien.f=#marge 
y1_ancien.f=#hauteur_ecran*0.25 
frequence1.f=100 

;-données courbe n°2 
x2_ancien.f=#marge 
y2_ancien.f=#hauteur_ecran*0.75 
frequence2.f=100 
x2_0=#marge 
sym=1 


frequence_echantillonnage.f=1000 

OpenWindow(0, 0, 0, #largeur_ecran, #hauteur_ecran, "Bizarre !", #PB_Window_SystemMenu | #PB_Window_ScreenCentered) 
StartDrawing(WindowOutput(0)) 
  ;-dessin des écrans 
  Box(0,#hauteur_ecran*0.5,#largeur_ecran,#hauteur_ecran*0.5,RGB(0,0,0)) 
  Box(0,0,#largeur_ecran,#hauteur_ecran*0.5-#marge,RGB(0,0,0)) 
  
  ;-tracé des courbes 
  For x=12 To 1000 
    
    ;-courbe n°1 ******************************************************************************* 
    frequence1= 10 + 0.02 * x
    
    y1=#hauteur_ecran*0.25-120*Sin(2*#PI*x/frequence1) 
    
    LineXY(x1_ancien,y1_ancien,x,y1,RGB(255,0,0)) 
    x1_ancien=x 
    y1_ancien=y1 
    
    
    ;-courbe n°2 ******************************************************************************** 
    If x<x2_0+frequence_echantillonnage/frequence2*0.5 
      
      y2=#hauteur_ecran*0.75-120*sym*Sin(2*#PI*frequence2*(x-x2_0)/frequence_echantillonnage) 
      
    Else 
      x2_0=x2_0+frequence_echantillonnage/frequence2*0.5 
      frequence2=100-0.1*x2_0 
      sym=-sym 
    EndIf 
    
    LineXY(x2_ancien,y2_ancien,x,y2,RGB(255,0,0)) 
    x2_ancien=x 
    y2_ancien=y2 
    
  Next x 
  
StopDrawing()    

Repeat : Until WaitWindowEvent() = #PB_Event_CloseWindow

Publié : ven. 30/janv./2009 17:10
par Huitbit
Heu, là, tu triches 8O
Puisque la variation de la fréquence n'est plus linéaire mais hyperbolique.
(elle se retrouve au dénominateur)

Code : Tout sélectionner

    ;-courbe n°1 ******************************************************************************* 
    frequence1= 10 + 0.02 * x 
    
    y1=#hauteur_ecran*0.25-120*Sin(2*#PI*x/frequence1) 
En tout cas, ça marche super bien et je crois que je vais adopter cette méthode qui allège le code et qui donne des variations plus "naturelles" !

MERCI !


Pour la variation linéaire, peut-être qu'un jour, on aura une explication :roll:

Hasta la vista !

Publié : ven. 30/janv./2009 17:37
par Le Soldat Inconnu
alors comme ça :)

Code : Tout sélectionner

;Bizarrerie du sinus modulé ? 
;auteur Huitbit 
;PureBasic 4.30 (Windows - x86) 

#largeur_ecran=1024 
#hauteur_ecran=768 
#marge=12 

;-données courbe n°1 
x1_ancien.f=#marge 
y1_ancien.f=#hauteur_ecran*0.25 
frequence1.f=100 

;-données courbe n°2 
x2_ancien.f=#marge 
y2_ancien.f=#hauteur_ecran*0.75 
frequence2.f=100 
x2_0=#marge 
sym=1 


frequence_echantillonnage.f=1000 

OpenWindow(0, 0, 0, #largeur_ecran, #hauteur_ecran, "Bizarre !", #PB_Window_SystemMenu | #PB_Window_ScreenCentered) 
StartDrawing(WindowOutput(0)) 
  ;-dessin des écrans 
  Box(0,#hauteur_ecran*0.5,#largeur_ecran,#hauteur_ecran*0.5,RGB(0,0,0)) 
  Box(0,0,#largeur_ecran,#hauteur_ecran*0.5-#marge,RGB(0,0,0)) 
  
  ;-tracé des courbes 
  For x=12 To 1000 
    
    ;-courbe n°1 ******************************************************************************* 
    frequence1= 100 - 0.05 * x 
    
    y1=#hauteur_ecran*0.25-120*Sin(2*#PI*x*frequence1/1000) 
    
    LineXY(x1_ancien,y1_ancien,x,y1,RGB(255,0,0)) 
    x1_ancien=x 
    y1_ancien=y1 
    
    
    ;-courbe n°2 ******************************************************************************** 
    If x<x2_0+frequence_echantillonnage/frequence2*0.5 
      
      y2=#hauteur_ecran*0.75-120*sym*Sin(2*#PI*frequence2*(x-x2_0)/frequence_echantillonnage) 
      
    Else 
      x2_0=x2_0+frequence_echantillonnage/frequence2*0.5 
      frequence2=100-0.1*x2_0 
      sym=-sym 
    EndIf 
    
    LineXY(x2_ancien,y2_ancien,x,y2,RGB(255,0,0)) 
    x2_ancien=x 
    y2_ancien=y2 
    
  Next x 
  
StopDrawing()    

Repeat : Until WaitWindowEvent() = #PB_Event_CloseWindow

Publié : ven. 30/janv./2009 17:59
par Huitbit
Ben non,
Si tu mets

Code : Tout sélectionner

frequence1= 100 - 0.08 * x 
tu retrouves le cas initial.
L'objectif, c'est de choisir une valeur de départ et une valeur finale pour la fréquence.
Ca doit donc fonctionner quelque soit l'équation !

Le coup de l'hyperbole, c'est très bien,(faut que je vérifie avec l'exponentielle, ça devrait marcher aussi!)

Hasta la vista!

Publié : ven. 30/janv./2009 19:26
par Ollivier
@Huitbit

Salut! Une application à ton problème ?

Une voiture de police qui se rapproche de toi avec sa sirène puis qui s'éloigne (aggravation du son lors de l'approche, inversion, puis remontée de la fréquence du son). Sinon, il ya Beny Benassi, Transe&Acid ou autre musique tech où tu retrouves ce phénomène accoustique dans certains sons.

Dans la théorie, tu as créé un modèle

Sin(K * Frq(x) )

K étant une constante
et Frq(x) un polynôme de degré 2 (ça va, c'est pas trop compliqué!)

Ton polynôme est -(1/10)*x*x + 100*x + 0
Modèle polynôme de degré 2 : A*x*x + B*x + C

Donc (!) par comparaison,
A = -(1/10)
B = 100
C = 0
(ça sent la fonction qui atteint le zéro)

Delta = B*B - 4*A*C
Delta = 10000

Donc Delta>0
Donc ton polynôme touche DEUX fois le zéro, dont une fois comme tu peux le voir à l'écran. (Si tu corriges C = -10000, Delta s'annule donc ton polynôme ne touchera plus qu'UNE seule fois le zéro, comme souhaité)

Sinon, pour éviter le désagrément de phase, ben... un rephasage aussi simple que de modifier 3 lettres dans ton code original : Sin par Cos.

Pour imager, c'est comme si ta courbe 1 était un fil de cuivre enroulé autour d'un rouleau de sopalin vide. Tu enroules dans un sens en ralentissant ta rotation, puis, jusqu'à l'arrêt de rotation, puis l'accélération dans l'autre sens. ça te donne ce que tu as à l'écran.

Changer «Sin» par «Cos» revient à tourner tout le rouleau de sop + le fil d'un quart de tour, et donc à dissimuler ce qui semblait être une annulation...

Woilà Huitbit!

PS: N'oublie pas le modèle Sin(K * Frq(x) ), c'est plus "réglo" pour comprendre ce qui se dessine.

Code : Tout sélectionner

;Bizarrerie du sinus modulé ? 
;auteur Huitbit 
;PureBasic 4.30 (Windows - x86) 
ExamineDesktops()
largeur_ecran=DesktopWidth(0)
hauteur_ecran=DesktopHeight(0)
DesktopDepth(0)
#marge=12 

;-données courbe n°1 
x1_ancien.f=#marge 
y1_ancien.f=hauteur_ecran*0.25 
frequence1.f=100 

;-données courbe n°2 
x2_ancien.f=#marge 
y2_ancien.f=hauteur_ecran*0.75 
frequence2.f=100 
x2_0=#marge 
sym=1 


frequence_echantillonnage.f=1000 

OpenWindow(0, 0, 0, largeur_ecran, hauteur_ecran, "Bizarre !", #PB_Window_SystemMenu | #PB_Window_ScreenCentered) 
StartDrawing(WindowOutput(0)) 
  ;-dessin des écrans 
Box(0,hauteur_ecran*0.5,largeur_ecran,hauteur_ecran*0.5,RGB(0,0,0)) 
Box(0,0,largeur_ecran,hauteur_ecran*0.5-#marge,RGB(0,0,0)) 
    
;-tracé des courbes 
For x=12 To 1000 

  ;-courbe n°1 ******************************************************************************* 
  frequence1=(100-0.1*x) 
  
  y1=hauteur_ecran*0.25-120*Cos(2*#PI*frequence1*x/frequence_echantillonnage) 
  
  LineXY(x1_ancien,y1_ancien,x,y1,RGB(255,0,0)) 
  x1_ancien=x 
  y1_ancien=y1 
  
  
  ;-courbe n°2 ******************************************************************************** 
  If x<x2_0+frequence_echantillonnage/frequence2*0.5 
  
    y2=hauteur_ecran*0.75-120*sym*Sin(2*#PI*frequence2*(x-x2_0)/frequence_echantillonnage) 
  
  Else 
    x2_0=x2_0+frequence_echantillonnage/frequence2*0.5 
    frequence2=100-0.1*x2_0 
    sym=-sym 
  EndIf 
  
  LineXY(x2_ancien,y2_ancien,x,y2,RGB(255,0,0)) 
  x2_ancien=x 
  y2_ancien=y2 
  
Next x 

StopDrawing()    

Repeat : Until WaitWindowEvent() = #PB_Event_CloseWindow 

Publié : ven. 30/janv./2009 21:24
par Huitbit
@Ollivier
Une voiture de police qui se rapproche de toi avec sa sirène puis qui s'éloigne (aggravation du son lors de l'approche, inversion, puis remontée de la fréquence du son).
C'est vrai que vu comme ça, c'est l'effet Doppler-Fizeau :roll:
Changer «Sin» par «Cos» revient à tourner tout le rouleau de sop + le fil d'un quart de tour, et donc à dissimuler ce qui semblait être une annulation...
Ce n'est pas ce que je veux faire ! Le code du Soldat Inconnu remplit bien cette fonction, partir d'une fréquence et arriver à une autre de manière monotone.

Quand je parle de bizarrerie, ça vient du fait qu'une fréquence qui diminue donnerait à priori un signal dont la fréquence diminue.
La présence du polynôme est bien responsable de ce comportement (il n'y a qu'à tracer sin(x²))
N'oublie pas le modèle Sin(K * Frq(x) ), c'est plus "réglo" pour comprendre ce qui se dessine
C'est vrai que sin(2*#pi*frequence*t) sorti de son contexte, ça peut paraître obscur :lol: donc MEA CULPA)

Merci de t'être penché sur le problème :wink:

Beaucoup de choses vont s'éclaircir lorsque je posterai mon utilitaire!

Hasta la vista!

Publié : dim. 01/févr./2009 19:01
par Ollivier
Dans la famille des bizarreries sinusoïdales, je poste ce petit code représentant la fonction Cos(x) à la puissance x. C'est à se demander s'il s'agit d'une fonction trigo tellement c'est tordu...

Code : Tout sélectionner

Structure XYC
   X.F
   Y.F
   Couleur.L
EndStructure

Structure LHBPPC
   Largeur.L
   Hauteur.L
   BitsParPixel.L
   Couleur.L
EndStructure

Structure DomaineReel
   Minimum.F
   Maximum.F
   Pas.F
EndStructure

   InitSprite()
   InitKeyboard()

Procedure Graphique()
   
   Protected i.L
   Protected j.L
   
   Protected Repere.XYC
   Protected Courbe.XYC
   Protected Ecran.LHBPPC

   Protected X.DomaineReel
   Protected Y.DomaineReel

   X\Minimum = 0.0 - 10.0
   Y\Minimum = 0.0 - 10.0   
   X\Maximum = 10.0
   Y\Maximum = 10.0
   Repere\Couleur = #Cyan   
   
   ExamineDesktops()
   Ecran\Largeur      = DesktopWidth(0)
   Ecran\Hauteur      = DesktopHeight(0)
   Ecran\BitsParPixel = DesktopDepth(0)
   Ecran\Couleur      = #Blue
   Courbe\Couleur     = #White
   
   With Ecran
      OpenScreen(\Largeur, \Hauteur, \BitsParPixel, "")
   EndWith
   
   Repere\X = (X\Minimum * Ecran\Largeur)
   Repere\X / (X\Minimum - X\Maximum)
   
   Repere\Y = (Y\Minimum * Ecran\Hauteur)
   Repere\Y / (Y\Minimum - Y\Maximum)
   
   X\Pas = Ecran\Largeur / (X\Maximum - X\Minimum)
   Y\Pas = Ecran\Hauteur / (Y\Maximum - Y\Minimum)
   
   Menu = 2
   Repeat
      ExamineKeyboard()
      ClearScreen(Ecran\Couleur)
      StartDrawing(ScreenOutput() )
         Line(Repere\X, 0, 0, Ecran\Hauteur, Repere\Couleur)
         Line(0, Repere\Y, Ecran\Largeur, 0, Repere\Couleur)
         For i = 0 To (Ecran\Largeur - 1)
            Courbe\X = ((i - Repere\X) / X\Pas)
            Courbe\Y = Pow(Cos(Courbe\X), Courbe\X)
               j = Repere\Y - Courbe\Y * Y\Pas
               If (j => 0)
                  If (j < Ecran\Hauteur)
                     Plot(i, j, Courbe\Couleur)
                     LineXY(i, Repere\Y, i, j, Courbe\Couleur)
                  Else
                     LineXY(i, Repere\Y, i, Ecran\Hauteur - 1, Courbe\Couleur)
                  EndIf
               Else
                  LineXY(i, 0, i, Repere\Y, Courbe\Couleur)   
               EndIf
         Next i
         If Menu = 1: ModeActuel.S = "Zoom": EndIf
         If Menu = 2: ModeActuel = "Déplacement": EndIf
         DrawingMode(#PB_2DDrawing_Transparent)
         DrawText(0, Ecran\Hauteur - 32, "Mode actuel: " + ModeActuel, #White)
         DrawText(0, Ecran\Hauteur - 16, "Z = Mode Zoom    D = Mode Déplacement    Flèches de direction = Modif param du mode choisi", #White)
         StopDrawing()
         FlipBuffers()
         Delay(15)
         Select Menu
            Case 1
               If KeyboardPushed(#PB_Key_Up)
                  Y\Minimum * 1.1   
                  Y\Maximum * 1.1          
                  ZoomModif = 1
               EndIf
               If KeyboardPushed(#PB_Key_Down)
                  Y\Minimum * 0.9   
                  Y\Maximum * 0.9          
                  ZoomModif = 1
               EndIf
               If KeyboardPushed(#PB_Key_Left)
                  X\Minimum * 1.1
                  X\Maximum * 1.1
                  ZoomModif = 1
               EndIf
               If KeyboardPushed(#PB_Key_Right)
                  X\Minimum * 0.9
                  X\Maximum * 0.9
                  ZoomModif = 1
               EndIf
            Case 2
               If KeyboardPushed(#PB_Key_Up)
                  New.F = (Y\Maximum - Y\Minimum) / 10.0
                  Y\Minimum - New   
                  Y\Maximum - New          
                  ZoomModif = 1
               EndIf
               If KeyboardPushed(#PB_Key_Down)
                  New.F = (Y\Maximum - Y\Minimum) / 10.0
                  Y\Minimum + New   
                  Y\Maximum + New          
                  ZoomModif = 1
               EndIf
               If KeyboardPushed(#PB_Key_Left)
                  New.F = (X\Maximum - X\Minimum) / 10.0
                  X\Minimum - New
                  X\Maximum - New
                  ZoomModif = 1
               EndIf
               If KeyboardPushed(#PB_Key_Right)
                  New.F = (X\Maximum - X\Minimum) / 10.0
                  X\Minimum + New
                  X\Maximum + New
                  ZoomModif = 1
               EndIf
         EndSelect
         If ZoomModif
            Repere\X = (X\Minimum * Ecran\Largeur)
            Repere\X / (X\Minimum - X\Maximum)
   
            Repere\Y = (Y\Minimum * Ecran\Hauteur)
            Repere\Y / (Y\Minimum - Y\Maximum)
   
            X\Pas = Ecran\Largeur / (X\Maximum - X\Minimum)
            Y\Pas = Ecran\Hauteur / (Y\Maximum - Y\Minimum)         
            ZoomModif = 0
         EndIf
         If KeyboardPushed(#PB_Key_W): Menu = 1: EndIf
         If KeyboardPushed(#PB_Key_D): Menu = 2: EndIf
         
      Until KeyboardPushed(#PB_Key_Escape)
   CloseScreen()
   End
EndProcedure

   Graphique()