Dessin rapide d'une ellipse.

Bonjour.

Je recherche le moyen de dessiner de multiples ellipses, sans passer par GDI.DLL, de façon à représenter un globe terrestre.

On devra absolument passer par la longitude et la latitude, et ne dessiner que la partie apparente, comme si on regardait le globe de face.

Merci de votre aide.

Code:

for longitude=-90 to 90 step 10
     for latitude=0 to 90 step 10
          ..............
     next latitude
next longitude

Salut Pedro

Ça ne répond pas exactement à ta demande, mais si ça peut t’aider dans ton projet, je serais très content.
Bon, je suis souvent très content !

Rappel de math pour tracer une sphère

On suppose que le centre de la sphère est le point O, origine du repère en 3D.
Une sphère est définie par son centre et son rayon R.
Un point M(x,y,z) appartient à la sphère si et seulement si OM = R.
L’équation de la sphère est donc : x² + y² + z² = R²
Cette formule n’est pas assez pratique pour tracer notre sphère.
Une autre approche consiste à déterminer la position d’un point M sur la sphère par le méridien et le parallèle sur lesquels il se trouve, ou encore par sa longitude et sa latitude.
Les coordonnées d’un point M sur la sphère dépendent des deux angles phi  (la longitude), et lambda (la latitude), avec phi compris entre 0 et 2pi, et lambda entre – pi/2 et pi/2.

On obtient l’équation paramétrique de la sphère avec les coordonnées du point M en fonction de phi et lambda.
x = R * cos(lambda) * cos(phi)
y = R * cos(lambda) * sin(phi)
z = R * sin(lambda)

Pour une position de l’œil de l’observateur par un angle alpha (qui peut-être nul), on peut visualiser les méridiens sur la sphère en ne gardant que la partie visible qui est une demi-sphère délimitée par le plan de projection.

Un point M(x,y,z) de l’espace se projette en M’.
Pour une projection sur les axes OX,OY, les coordonnées de M’ dans le plan de projection sont données par les équations suivantes :
Xp = x / sqr(2) – y / sqr(2) = (1/sqr(2)) * (x-y)
Yp = x * sin(alpha) / sqr(2) + y * sin(alpha) / sqr(2) + z * cos(alpha)  =  (sin(alpha) / sqr(2)) * (x + y) + z * cos(alpha)

Formules de passage de la 3D vers l’écran

Le plan de projection n’est autre que notre écran de l’ordinateur avec les précautions suivantes :
• Pratiquer un zoom (n’oubliez pas que notre sphère à un rayon de 1)
• Faire une translation des axes, avec le point origine O de coordonnées (xorigine, yorigine) sur l’écran.


Le projeté du point M a comme coordonnées :
Xecran = xorigine + a * (x-y)
yecran = yorigine - b * (x+y)- c * z
avec
a = zoom / sqr(2)
b = zoom *  sin(alpha) / sqr(2)
C = zoom * cos(alpha)

Au final ce sont des formules très simples pour passer de l’espace 3D à sa visualisation sur l’écran.


Equation du plan de projection

Ce plan étant perpendiculaire aux rayons issus de l’œil, il a pour vecteur normal (perpendiculaire à lui et de longueur 1) le vecteur N de coordonnées :
(cos(alpha) / sqr(2)) * x  +  (cos(alpha) / sqr(2)) * y  - sin(alpha) * z  =  0
Ou, en simplifiant
x + y – c1*z  = 0 ; avec c1 = sqr(2) * tan(alpha)

Si x + y – c1*z  < 0, alors le point est invisible.


Le code suivant est une application de ce qui précède.

Code:

============================================================================
rem     Tracé d’une sphère en visualisant les méridiens de la partie visible
rem ============================================================================
dim alfa : alfa = pi/4 : ' inclinaison de l'oeil, vous pouvez choisir une inclinaison 0
dim zoom : zoom = 200  : ' zoom sur la sphère de rayon 1
dim a : a = zoom / sqr(2)
dim b : b = zoom * sin(alfa) / sqr(2)
dim c : c = zoom * cos(alfa)
dim r : r = 1  : ' rayon unité de la sphère
dim phi, lambda
dim x,y,z  : ' coordonnées de la sphère en 3D
dim c1 : c1 = sqr(2) * tan(alfa)
dim xe,ye : ' coordonnées ecran
dim xorigine : xorigine = width_client(0) /2
dim yorigine : yorigine = height_client(0)/2
dim p : p = pi / 25
picture 10 : full_space 10 : 2d_target_is 10

for phi = 0 to 2*pi step p : ' les méridiens
    2d_poly_from xorigine ,yorigine  +  zoom : ' + zoom/2
    for lambda = 0-pi/2 to pi/2 step 0.01
        x = R*cos(lambda)*cos(phi)
        y = R*cos(lambda)*sin(phi)
        z = R*sin(lambda)
        xe = xorigine + a * (x-y) : ye = yorigine - b * (x+y)- c * z
        
        if (x+y-c1*z) < 0 : ' partie visible ?
           2d_pen_color 0,0,0 : 2d_poly_to xe,ye : ' tracé en noir
        else
           ' partie cachée
           2d_pen_color 240,240,240 : 2d_poly_to xe,ye : ' tracé en gris
        end_if
        display
    next lambda
next phi
rem ============================================================================

Bon divertissement mathématico-astronomico-panoramico-programmation !

Salut Pedro !
Bonjour à tous !

Idée :

Code:

WIDTH 0,800
HEIGHT 0,800
dim i,j%,x,y,a
DEGREES
FOR j% =0 to 350 STEP 20
    FOR i=0 to 360 STEP 0.3
       x=j%*cos(i)+400
       y=350*sin(i)+400
       2D_POINT x,y
    NEXT i
NEXT j%
FOR j% =0 to 350 STEP 20
    FOR i=0 to 360 STEP 0.3
       x=350*cos(i)+400
       y=j%*sin(i)+400
       2D_POINT x,y
    NEXT i
NEXT j%
END

Peut-être mettre la trame générée une fois pour toute en mémoire dans un IMAGE pour pouvoir l'appeler instantanément quand tu en as besoin.

Bonne continuation !

Autre idée avec aspect visuel 3D :

Code:

WIDTH 0,800
HEIGHT 0,800
dim i,j,x,y
DEGREES
FOR j =0 TO 90 STEP 10
    FOR i=0 TO 360 STEP 0.3
       x=COS(j)*350*COS(i)+400
       y=350*SIN(i)+400
       2D_POINT x,y
    NEXT i
NEXT j
FOR j =0 TO 90 STEP 10
    FOR i=0 TO 360 STEP 0.3
       y=COS(j)*350*COS(i)+400
       x=350*SIN(i)+400
       2D_POINT x,y
    NEXT i
NEXT j
END

C'est curieux que personne n'ait proposé l'algorithme de Bresenham qui est l'un des plus rapides car il ne fait appel à aucune fonction trigonométrique (ni sinus ni cosinus) ou mathématique (racine carrée).
Il n'utilise que les 4 opérations de base (addition, soustraction, multiplication, division).

Le voici sous forme de métalangage:

Code:

PROCEDURE ellipse(a, b : integer)
DECLARATION
   x,y : integer;
   d1,d2 : Reel;
DEBUT
  // 1ere phase  
   x <- 0 ;
   y <- b ;
  d1 <- b2 - a2*b + a2/4 ;
  CALL allume_pixel(x,y) ;
  TANSQUE ( a2*(y-.5) > b2*(x+1) ) FAIRE
  DEBUTTANSQUE
    SI ( d1 >= 0 )  ALORS
    DEBUTSI
      d1 <- d1+ b2*(2*x+3) + a2*(-2*y+2) ;
      x <- x+1 ;
      y <- y -1  
   SINON
       d1 <- d1+ b2*(2*x+3) ;
       x <- x+1 ;
    FINSI
    CALL allume_pixel(x,y) ;
  FINTANSQUE
   // 2eme phase
   d2 <- b2*(x+.5)2 + a2*(y-1)2 - a2*b2 ;
  TANSQUE ( y > 0 )  FAIRE
  DEBUTTANSQUE
     SI ( d2 < 0 )  ALORS
     DEBUTSI
       d2 <- d2 +b2*(2*x+2) + a2*(-2*y+3) ;
       y <- y -1 ;
       x <- x+1 ;
     SINON
        d2 <- d2 + a2*(-2*y+3) ;
        y <- y -1
     FINSI
     CALL allume_pixel(x,y) ;
  FINTANSQUE
FIN

et son implémentation en C:

Code:

void ellipse(long a,long b) {
   int x,y ;
   double d1,d2 ;
   x = 0 ;
   y = b ;
   d1 = b*b - a*a*b + a*a/4 ;
   allume_pixel(x,y) ;
   while ( a*a*(y-.5) > b*b*(x+1) ) {
   if ( d1 < 0 ) {
     d1 += b*b*(2*x+3) ;
     x++ ; }
     else {
     d1 += b*b*(2*x+3) + a*a*(-2*y+2) ;
     x++ ;
     y-- ; }
   allume_pixel(x,y) ; }
   d2 = b*b*(x+.5)*(x+.5) + a*a*(y-1)*(y-1) - a*a*b*b ;
   while ( y > 0 ) {
   if ( d2 < 0 ) {
     d2 += b*b*(2*x+2) + a*a*(-2*y+3) ;
     y-- ;
     x++ ; }
     else {
     d2 += a*a*(-2*y+3) ;
     y-- ; }
   allume_pixel(x,y) ; }
 }

Cet algorithme est un algorithme de base en infographie (car très rapide) avec le tracé de segments, de cercles et d'arc de cercle, qui n'utilisent aussi que les 4 opérations.

Voici le code de Marc réadapté en sous-programme paramétrés

Code:

em ============================================================================

Globe(width_client(0) / 2, height_client(0)/2, 200)
end
rem ============================================================================
SUB Globe(xc,yc,r)
    dim_local i,j,x,y
    DEGREES
    FOR j = 0 to r STEP 20
        2d_poly_from xc+j , yc
        FOR i = 0 to 360
            x = j*cos(i) + xc  : y = r * sin(i) + yc : 2D_POly_to x,y  
        NEXT i
    NEXT j

    FOR j = 0 to r STEP 20
        FOR i = 0 to 360
            x = r*cos(i) + xc : y = j*sin(i)+ yc : 2D_POly_to x,y
        NEXT i
    NEXT j
END_SUB
rem ============================================================================

Tiens je suis surpris. Toi Papydall qui adore les maths tu n'en a pas profité pour appliquer l'algorithme de Bresenham ?

Jack a écrit:

C'est curieux que personne n'ait proposé l'algorithme de Bresenham qui est l'un des plus rapides ...

Jicehel a écrit:

Tiens je suis surpris. Toi Papydall qui adore les maths tu n'en a pas profité pour appliquer l'algorithme de Bresenham ?

Il y a plus de 3 ans, j’ai proposé une demonstration de   l’algorithme de Bresenham (cliquez SVP)

J’ai repris cet algorithme ici, il y a seulement 3 jours.      

Voici une adaptation en Panoramic.

Dessin d'un arc d'ellipse:

Code:

dim tx%,ty%: rem translations sur les axes
picture 1
tx%=50
ty%=50
ellipse(20,50)
end

SUB ellipse(a%,b%)
DIM_LOCAL x%,y%,d1,d2
x%=0
y%=b%
d1=b%*b%-a%*a%*b%+a%*a%/4
2D_POINT x%+tx%,y%+ty%
WHILE a%*a%*(y%-0.5) > b%*b%*(x%+1)
  IF d1 >= 0
    d1=d1+b%*b%*(2*x%+3)+a%*a%*(2-2*y%)
    x%=x%+1
    y%=y%-1
  ELSE
    d1=d1+ b%*b%*(2*x%+3)
    x%=x%+1
  END_IF
  2D_POINT x%+tx%,y%+ty%
END_WHILE
d2=b%*b%*(x%+0.5)*(x%+0.5)+a%*a%*(y%-1)*(y%-1)-a%*a%*b%*b%
WHILE y% > 0
  IF d2 < 0
    d2=d2+b%*b%*(2*x%+2)+a%*a%*(3-2*y%)
    y%=y%-1
    x%=x%+1
  ELSE
    d2=d2+a%*a%*(3-2*y%)
    y%=y%-1
  END_IF
  2D_POINT x%+tx%,y%+ty%
END_WHILE
END_SUB

Une ellipse complète peut être dessinée en jouant avec les symétries.
Attention, cet algorithme dessine une ellipse point par point. On peut aller plus vite en l'adaptant avec 2D_POLY_FROM et 2D_POLY_TO pour tracer des segments au lieu de points.

Voici l’adaptation en Panoramic de l’algorithme décrit par Jack en métalangage:

Code:

rem ============================================================================
dim xc,yc : ' centre de l'ellipse
xc = 250 : yc = 200
Arc_Ellipse(150,100)
end
rem ============================================================================
SUB Arc_Ellipse(a,b)
    dim_local x,y,d1,d2
    x = 0 : y = b : d1 = b*b - a*a*b + a*a/4
    2d_poly_from xc + x, yc + y
    while a*a*(y - 0.5) > b*b*(x+1)
          if d1 < 0
            d1 = d1 + b*b*(2*x+3)
            x = x + 1
          else
            d1 = d1 + b*b*(2*x+3) + a*a*(2-2*y)
            x = x + 1 : y = y - 1
          end_if
          2d_poly_to xc +x, yc +y
    end_while
    d2 = b*b*(x+0.5)*(x+0.5) + a*a*(y-1)*(y-1) - a*a*b*b
    while y > 0
          if d2 < 0
            d2 = d2 + b*b*(2*x+2) + a*a *(3-2*y)
            y = y - 1 : x = x + 1
          else
            d2 = d2 + a*a*(3-2*y)
            y = y - 1
          end_if
          2d_poly_to xc+x, yc+y
    end_while
         
END_SUB
rem ============================================================================

Pour me rattraper, voici un code pour tracer une ellipse entière ou un cercle et non seulement un arc.

Code:

rem ============================================================================
rem      Code optimisé pour dessiner une ellipse
rem        de centre xc,yc et de rayons a et b
rem ============================================================================
rem REF : http://members.chello.at/easyfilter/Bresenham.pdf
rem ============================================================================

Ellipse(250,200,150,100) : ' ellipse large
Ellipse(250,200,100,150) : ' ellipse haute
Ellipse(250,200,200,200) : ' cercle

end
rem ============================================================================
SUB Ellipse(xc,yc,a,b)
    dim_local x,y,e2,err,dx,dy
    x  = 0-a : y  = 0 : ' II. quadrant from bottom left to top right
    e2 = b 
    dx = (1+2*x)*e2*e2  : ' error increment
    dy = x*x : err = dx + dy : ' error 1.step
   
    repeat
        2d_point xc-x, yc+y : ' quadrant I
        2d_point xc+x, yc+y : ' quadrant II
        2d_point xc+x, yc-y : ' quadrant III
        2d_point xc-x, yc-y : ' quadrant IV
        e2 = 2*err
        if e2 >= dx
            x = x + 1 : dx = dx + 2*b*b : err = err + dx : ' x step
        end_if
        if e2 <= dy
            y = y + 1 : dy = dy + 2*a*a : err = err + dy : ' y step
        end_if
    until x > 0
       
END_SUB
rem ============================================================================

Je me disais aussi que ce n'était pas le genre de Papydall de ne pas relever ce petit challenge

Bonjour.

Merci à tous de votre aide.
Votre participation m'a permis de bien avancer.

Cependant, je rencontre un petit problème, avec le code suivant.
Le cercle, qui devrait apparaître en (30°,30°) ne se place pas à la bonne position.

L'un d'entre vous pourrait-il regarder pourquoi ?

Merci.

Code:

' Version du 6 juin 2018.
' Hauteur au-dessus de l'horizon:
' de 180% à 270% -> à gauche de l'axe central.
' de 270% à 360% -> à droite de l'axe central.

' Azimuth: de 0° à 180° (gauche vers droite)

dim az, zoom, h, xc, yc, x, y, r, facteur, i%, arg

maximize 0

font_color 0,255,0,0:font_size 0,12:font_bold 0

' Centre du globe.
xc=width_client(0)/2
yc=height_client(0)/2+100

r=360
zoom=1.5

DEGREES

Globe(r)

az=30
h=30
calculer_x_y(az,h)
2d_pen_color 0,0,0   
for i%=1 to 5
    2d_circle x,y,i%
next i%

end
 
SUB Globe(r) 
    ' Lignes verticales.
    ' Azimuths.
    FOR az=0 to 360 STEP 120
        i%=0
        ' Hauteurs
        FOR h=180 to 360
            i%=i%+1
            x=zoom*(az*cos(h))+xc : y=zoom*(r*sin(h))+yc
            if i%=1
              2D_poly_from x,y
                  else
              2D_POly_to x,y 
            end_if
            if h=180 or h=360
              facteur=1:if x<xc then facteur=-1
              arg=facteur*az/4:if arg<0 then arg=arg+360
              print_x_locate x+5:print_y_locate y+5:print str$(arg)+"°"
            end_if
        NEXT h
    NEXT az

    ' Lignes horizontales.
    ' Hauteurs.
    FOR h=0 to r STEP 120
        i%=0
        ' Azimuths.
        FOR az=180 to 360
            i%=i%+1
            x=zoom*(r*cos(az))+xc : y=zoom*(h*sin(az))+yc
            if i%=1
              2D_poly_from x,y
                  else
              2D_POly_to x,y 
            end_if 
            if x=xc
              facteur=1:if y>yc then facteur=-1
              print_x_locate x+5:print_y_locate y+5:print str$(facteur*h/4)+"°"
            end_if
        NEXT az
    NEXT h
END_SUB

sub calculer_x_y(az,h)
    if az<0
      h=h+180
          else
      h=h+270 
    end_if
   
    x=zoom*(r*cos(az+270))+xc
    y=zoom*(h*sin(az+270))+yc
end_sub

C'est manifestement un bug, et qui ne vient pas de ton programme.

On dirait que PRINT modifie la valeur d'un 2D_POLY_FROM ou d'un 2D_POLY_TO.
Il faut que je regarde cela de près...car le problème ne saute pas aux yeux à la simple lecture du code de PRINT ou de 2D_POLY_FROM ou 2D_POLY_TO.

Jack a écrit:

C'est manifestement un bug, et qui ne vient pas de ton programme.

On dirait que PRINT modifie la valeur d'un 2D_POLY_FROM ou d'un 2D_POLY_TO.

La commande PRINT affiche son argument à la position actuelle du curseur texte puis modifie la position de ce même curseur qui est également curseur graphique, de sorte que la nouvelle commande 2d_POLY_TO utilisera la dernière position du curseur texte.

Ce n’est pas un bug du moment que le curseur texte et le curseur graphique ne sont en fait qu’un seul et unique curseur.
Si on utilise PRINT puis 2D_POLY_TO, le tracé partira de la dernière position, à savoir celle modifiée par PRINT en « oubliant » la dernière position de 2D_POLY_FROM ou de 2D_POLY_TO.

Exécuter le code suivant puis mettez la ligne 2 en REM, vous verrez le problème.
Mais, pour moi, ce n’est pas un bug.
Il faut simplement en tenir compte si on mélange affichage texte et tracé graphique.
On peut penser à sauvegarder la dernière position du curseur graphique avant un affichage par PRINT (ou PRINT_LOCATE) et le restaurer ensuite.

Code:

2d_poly_from 300,200  : 2d_poly_to 400,100
print : print : print "hello"
2d_poly_to 200,150
2d_poly_to 150,200
2d_poly_to 500,400

Maintenant le code modifié pour tenir compte de la modification de la position du curseur.

Code:

dim whereX, whereY
2d_poly_from 300,200 : 2d_poly_to 400,100
whereX = 400 : WhereY = 100 : ' on sauvegarde la dernière position du curseur graphique
print : print : print "hello"
2d_poly_from whereX,WhereY : ' on restaure l'ancienne position graphique
2d_poly_to 200,150
2d_poly_to 150,200
2d_poly_to 500,400