Bonjour.

Je dois dessiner une ellipse commençant par le quatrième quadrant, basée sur l'algorithme du point médian. J'ai un code qui trace le premier, mais je ne comprends pas comment modifier la formule pour le faire fonctionner avec le quatrième. Je pensais simplement inverser l'axe Y, mais ce n'est pas autorisé par mon professeur (trop facile). :/

void ellipseMedian(MyGrillePixels & g, int xC, int yC, int rayonX, int rayonY){
    // Premier quadrant
    int x=0, y=rayonY, d, deltaE, deltaSE;
    int b2=rayonY*rayonY, a2=rayonX*rayonX;

    d = 4*b2 + a2*(1-4*rayonY);

    g.allumerPixel(0+xC,rayonY+yC,126,20,251); // Allumage du promier et de ses 3 symétriques
    g.allumerPixel(0+xC,-rayonY+yC,126,20,251);
    g.allumerPixel(rayonX+xC,0+yC,126,20,251);
    g.allumerPixel(-rayonX+xC,0+yC,126,20,251);

    while(2*b2*(x+1) < a2*(2*y-1)){ // 1ère région
        if(d<0){ // Mouvement vers l'est
            d+=b2*(8*x+12);
            x++;
        }else{ // Mouvement vers Sud Est
            d+= b2*(8*x+12)+8*a2*(1-y);
            x++; y--;
        }

        g.allumerPixel(x+xC,y+yC,126,20,251);
        g.allumerPixel(-x+xC,y+yC,126,20,251);
        g.allumerPixel(-x+xC,-y+yC,126,20,251);
        g.allumerPixel(x+xC,-y+yC,126,20,251);
    }

    // 2ème région
    d = b2*(2*x+1)*(2*x+1) + 4*a2*(y-1)*(y-1)-4*a2*b2;

    while(y>0){
        if(d<0){ // Mvt SE
            d+= a2*(12-8*y)+b2*(8*x+8);
            x++;
            y--;
        }else{ // Mvt S
            d+= a2*(12-8*y);
            y--;
        }
        g.allumerPixel(x+xC,y+yC,126,20,251);
        g.allumerPixel(-x+xC,y+yC,126,20,251);
        g.allumerPixel(-x+xC,-y+yC,126,20,251);
        g.allumerPixel(x+xC,-y+yC,126,20,251);
    }

    while(x<rayonX){
        g.allumerPixel(x+xC,y+yC,126,20,251);
        g.allumerPixel(-x+xC,y+yC,126,20,251);
        g.allumerPixel(-x+xC,-y+yC,126,20,251);
        g.allumerPixel(x+xC,-y+yC,126,20,251);
        x++;
    }
}

Comment pourrais-je faire pour transformer l'algorithme de sorte à tracer la quatrième quadrant, sans inverser l'axe y sur les fonction "allumerPixels" ?

Merci d'avance pour l'aide. 

Je ne sais pas dans quel langage tu as programmé cette fonction. Ça ressemble à du C++.
Je ne connais pas vraiment cette méthode.
Je suppose que ton ellipse est "centrée" en (XC, YC) et l'excentricités en X va de -rayonX à +rayonX, et l'excentricité en Y va de -rayonY à +rayonY.
Pour chaque position de X, on devrait pouvoir obtenir "les" positions de Y?

L'équation de l'ellipse n'est-elle pas:
AX² + BY² = C
Pour Y==0, X = ± sqrt(C/A)
pour X==0, Y = ± sqrt(C/B)
Pour X donné, Y = ± sqrt((C-AX²)/B)
Je ferait varier X de +rayonX vers -rayonX par petits pas, et je calculerais les Y (positifs) correspondants.
Puis je ferais varier X de -rayonX à +rayonX et je calculerais les Y (négatifs) correspondants.
(tout cela décalé de XC et YC)
Tu fais tes calculs avec des entiers (int). Je ne sais pas si c'est une bonne idée.
As-tu suffisamment de précision? Y a-t-il des "trous" dans ton tracé?

-
Edité par PierrotLeFou 2 avril 2022 à 3:47:30

Ce n'est pas grave oublie. J'ai également posé cette question, et une personne m'ayant répondu m'a dit (en anglais) que c'était d'une "stupidité dense" de commencer le calcul par le quatrième quadrant, et que justement le but de cet algorithme était d'utiliser la symétrie. x)

Pour ma part, n'ayant rien compris au cours du prof, je ne m'attend à pas grand chose concernant la note.

Merci quand même d'avoir pris le temps de me répondre.