Trouvez le point d'un cercle dont le centre, le rayon et le degré sont donnés.

Question

Cela fait 10 ans que je n'ai pas fait de calcul de ce genre... Je suis en train de programmer un jeu en 2D et de déplacer un joueur. Lorsque je déplace le joueur, j'essaie de calculer le point d'un cercle situé à 200 pixels de la position du joueur, en fonction d'un angle (degré) positif OU négatif compris entre -360 et 360. L'écran est de 1280x720 avec 0,0 étant le point central de l'écran. Le joueur se déplace dans tout ce système de coordonnées cartésiennes. Le point que j'essaie de trouver peut être hors de l'écran.

J'ai essayé les formules de l'article Trouvez le point avec le rayon et l'angle mais je ne crois pas que je comprenne ce qu'est "Angle" car j'obtiens des résultats bizarres lorsque je passe Angle comme -360 à 360 dans un Cos(angle) ou Sin(angle).

Donc, par exemple, j'ai...

• 1280x720 sur un plan cartésien
• Point central (la position du joueur) :
  • let x = un nombre entre le minimum -640 et le maximum 640
  • let y = un nombre entre le minimum -360 et le maximum 360
• Rayon du cercle autour du joueur : let r always = 200
• Angle : a = un nombre donné entre -360 et 360 (on peut indiquer un nombre négatif pour pointer vers le bas ou positif pour pointer vers le haut, donc -10 et 350 donnent la même réponse).

Quelle est la formule pour retourner X sur le cercle ?

Quelle est la formule pour ramener Y sur le cercle ?

Answer 1

Voici l'implémentation c#. La méthode renvoie les points circulaires qui prennent radius , center y angle interval comme paramètre. L'angle est passé en Radian.

public static List<PointF> getCircularPoints(double radius, PointF center, double angleInterval)
        {
            List<PointF> points = new List<PointF>();

            for (double interval = angleInterval; interval < 2 * Math.PI; interval += angleInterval)
            {
                double X = center.X + (radius * Math.Cos(interval));
                double Y = center.Y + (radius * Math.Sin(interval));

                points.Add(new PointF((float)X, (float)Y));
            }

            return points;
        }

et l'exemple d'appel :

List<PointF> LEPoints = getCircularPoints(10.0f, new PointF(100.0f, 100.0f), Math.PI / 6.0f);

Answer 2

Je voulais partager comment vos contributions ci-dessus m'ont aidé à produire une boussole Arduino LCD. J'espère que c'est la bonne étiquette... Je viens de rejoindre stackoverflow pour pouvoir vous remercier.

C'est en m'appuyant sur les épaules des géants de la géométrie ci-dessus que j'ai pu produire cet exemple de boussole : Boussole Arduino TFT à roulements multiples

Le code de la fonction que j'ai appelée à plusieurs reprises (pour les différents paliers que vous voyez en petit texte jaune) est écrit en Arduino (un peu comme du "C")... et est assez traduisible :

void PaintCompassNeedle( int pBearingInDegrees, int pRadius, TSPoint pCentrePt ) {
    // ******************************************************************************
    // * Formula for finding pointX on the circle based on degrees around the circle:
    // * x_oncircle = x_origin + radius * cos (degrees * pi / 180)  
    // * y_oncircle = y_origin - radius * sin (degrees * pi / 180) //minus explained
    // * Thanks to folks at stackoverflow...standing on the shoulders of giants. :) 

    float bearingInRads = (pBearingInDegrees) * PI / 180; 
    // Degrees vs Rads...The math folks use Rads in their formulas

    // *******************************************************************
    // * bearingPt is the point on the circle that we are trying to find
    TSPoint bearingPt;
    // Find the X on the circle starting with orgin (centre)
    bearingPt.x = pCentrePt.x + pRadius * sin(bearingInRads); 
    // Notice the "minus" R * cos()...because TFT the y is upside down bearingPt.y = 
    pCentrePt.y - pRadius * cos(bearingInRads); 
    // * Extra Explanation: The TFT is the graphical display I'm using and it
    // * calculates x & y from the top left of screen (portrait mode) as (0,0)
    // * ...so by Subtracting from the Y orgin...I flip it vertically
    // * Other folks using x,y as increasing to the right and up respectively
    // * would keep the plus sign after the pCentrePt.y
    // *************************************************************************

    // ***************************************************************
    // * This part will change for the final product...but leaving
    // * it because when call numerous times it shows it working for
    // * a number of different quadrants (displaying yellow degrees text)
    tft.fillCircle( bearingPt.x, bearingPt.y, 5, RED); 
    tft.setCursor( bearingPt.x, bearingPt.y );
    tft.setTextSize( 1 );
    tft.setTextColor( YELLOW );
    tft.print( pBearingInDegrees );

    TSPoint innerPt;
    innerPt.x = pCentrePt.x + pRadius/2 * sin(bearingInRads);
    innerPt.y = pCentrePt.y - pRadius/2 * cos(bearingInRads);
    tft.drawLine(innerPt.x, innerPt.y, bearingPt.x, bearingPt.y, RED);

}

Answer 3

La réponse devrait être exactement l'inverse.

X = Xc + rSin(angle)

Y = Yc + rCos(angle)

où Xc et Yc sont les coordonnées du centre du cercle et r est le rayon.

Answer 4

Recommandez :

public static Vector3 RotatePointAroundPivot(Vector3 point, Vector3 pivot, Vector3 angles)
{
    return Quaternion.Euler(angles) * (point - pivot) + pivot;
}

Answer 5

Vous pouvez utiliser ceci :

Equation du cercle où

(x-k) 2 +(y-v) 2 \=R 2

où k et v sont constants et R est le rayon