Connaître l'angle par rapport au premier point du vecteur

Bonjour,

Grâce à mon autre sujet, je sais si l’OVNI est à ma gauche ou à ma droite. Maintenant je souhaite pouvoir cadrer la photo correctement, je dois donc connaitre l’angle de l’OVNI avec moi (point A-312. C’est logique, je suis le point A! ) (donc l’angle $\stackrel \frown \text{AOB}$).

Comment dois-je procéder pour connaître l’angle $\stackrel \frown \text{AOB}$ ?

Ma supposition :

Je pense que je dois utiliser Pythagore, une fois que je connais le côté adjacent de $\stackrel \frown \text{AOB}$.

Il me semble que je dois prolonger $\vec{AO}$ et placer le point $O^\prime$ de sorte à former le triangle rectangle $AO^{\prime}B$.

Je ne sais pas comment obtenir la position de $O^\prime$.

Bon vol,

A.

le produit vectoriel (ou le déterminant)

Je ne savais pas que c’était la même chose.

Alors sur : http://paquito.amposta.free.fr/glossp/prodscal.htm que signifie "||" ?

EDIT : Mauvais lien + Suppression de la partie, j’allais dans une mauvaise direction.

J’ai improvisé un autre essai, c’est faux

• $\mathrm{A(5;1)}$
• $\mathrm{B(1;4)}$
• $\mathrm{O_{\text{vni}}(2;1)}$

Donc :

• $\mathrm{\vec{AB}(-4;3)}$
• $\mathrm{\vec{AO}(-3;1)}$

Alors :

Puis :

Tu connais la longueur de tes vecteurs. Ce que tu cherches, c’est $\cos(\gamma)$

Je n’ai pas trouvé de documentation liée à Gamma/γ.

TAN ? Mais je n’ai pas le côté opposé

EDIT : Si avec : $\text{tan2}((B_x - A_x)/(B_y - A_y))$

EDIT2 : Mon précédent edit est faux. Je ne l’ai pas car il me manque un bout du côté adjacent, ma première explication était fause.

• $\mathrm{A(5;1)}$
• $\mathrm{B(1;4)}$
• $\mathrm{O_{\text{vni}}(2;1)}$

Donc :

• $\mathrm{\vec{AB}(-4;3)}$
• $\mathrm{\vec{AO}(-3;1)}$

Je pense avoir trouvé :

$\overrightarrow{AB}\;.\;\overrightarrow{AO_{\text{vni}}} = \begin{pmatrix} -4 \\ 3 \end{pmatrix}.\begin{pmatrix} -3 \\ 1 \end{pmatrix}) = -4 * (-3) + 3 * 1 = 15$

Avec :

Donc :

Non la fonction atan2 de la lib math, qui prend une ordonnée et une abscisse et renvoie un angle en radians. Elle est préférable à arccos ou arcsin car comprend tout le cercle trigonométrique, là où les deux autres se limiteront à des demi-cercles.

Si je comprends : https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Math/atan2

Quand je fais

Math.atan2(3,3)*180/Math.PI

C’est comme si j’avais un triangle ABC : A(0;0) B(3;0) C(3;3) et il me donne l’angle de BAC ?

Avant de faire ce sujet j’utilisais Math.atan2 sans visualiser correctement que c’était un angle universelle avec mes tests je savais que c’était la fonction la plus adapté mais j’avais du mal à traiter le résultat que j’obtenais donc je me retrouvais avec un résultat final faux :

Mais en me penchant sur le sujet j’ai pu corriger grâce à cette visualisation. Merci.

J’ai pu réaliser la ligne 8 et 16 sachant que je comprenais vraiment le résultat d’atan2, on constate que ma solution n’est pas très mathématique :

function getAngle(a, b) {
    const x = b.x - a.x,
          y = b.y - a.y,
          dx = (x < 0) ? -1 : 1,
          dy = (y < 0) ? -1 : 1,
          atan2 = Math.atan2(Math.abs(y), Math.abs(x));
 
    let axe; // Chaque valeur de axe à +90 car sens horaire
    if (dx === 1 && dy === 1)
        axe = 90;
    else if (dx === -1 && dy === 1)
        axe = 180;
    else if (dx === -1 && dy === -1)
        axe = 270;
    else if (dx === 1 && dy === -1)
        axe = 360;
    //                   /\ dy est inversé dans les 4 conditions
    //                      pour que SUD soit égale à 90.

    return axe - Math.round(atan2 * 180 / Math.PI);
    //        /\ soustraction pour le sens horaire
}

function correction180(angle) {
    if (angle > 180) {
        return 180 - angle;
    } else if (angle < -180) {
        return 360 + angle;
    } else {
        return angle;
    }
}

correction180(orientationNSWE - getAngle(positionXY, destinationXY))

On peut gérer la ligne 8 et 16 comme ci-dessous, mais ça complexifie le code.

const axe = 90 * (1 + (dx * dy == -1) + (dy == -1) * 2);

Pour essayer dans la console web :

((dx, dy) => 90 * (1 + (dx * dy == -1) + (dy == -1) * 2))(1, -1)

EDIT : Ou :

const axe = 90 * (1 + (dx != dy) + (dy == -1) * 2);

Je ne comprends pas ce que tu essaies de faire à partir du résultat d'atan2. Enfin je vois bien que tu veux convertir la valeur en degrés (est-ce réellement utile ?), mais pour le reste ?

Enfin je vois bien que tu veux convertir la valeur en degrés (est-ce réellement utile ?), mais pour le reste ?

L’entrée orientationNSWE est en degrés je suis donc obligé de faire la conversion.

getAngle(positionXY, destinationXY) me donne l’angle du vecteur (donc de mon mouvement) sous le même format que orientationNSWE : E=0°, S=90°, W=180°, N=270°.

orientationNSWE est l’angle absolu de mon regard (E=0°, S=90°, W=180°, N=270°)

En soustrayant l’angle du vecteur avec orientationNSWE, j’obtiens le delta qui représente la direction où regarder pour prendre ma photo. Où angle=0 est le nez de l’appareil et angle=180 ou angle=-180 la queue, angle=-90 ou angle=90 le côté droit ou gauche.

Pour ma condition :

                N=270
                  |
      dx=1, dy=-1 | dx=1, dy=1
                  |
W=180-------------+-------------E=0 ou 360
                  |
     dx=-1, dy=-1 | dx=1, dy=-1
                  |
                 S=90

J’ai dû inversé dy car le nord-sud est inversé dans l’entrée orientationNSWE.

Je ne comprends pas ce qu’est cette orientationNSWE, c’est une valeur à toi ? Tu la décris comme un ensemble de quatre nombres, mais la manière dont tu l’utilises laisse penser que c’est un seul nombre, donc je suis perdu.

orientationNSWE est mon angle sur l’axe Nord, Sud, Ouest et Est.

Si je regarde à l’est alors angle = 0°, si je regarde au sud 90°, ouest 180° et nord 270°.

EDIT : Mon doigt a glissé, j’ai cliqué sur envoyer au lieu d’aperçu

Ah, d’accord, j’avais mal lu/compris. C’est donc simplement l’angle exprimé en degré et dans le sens indirect.

Tu ne pourrais pas plutôt l’avoir dans le sens direct (donc 90° au Nord et 270 au Sud) ? Ce serait plus simple je pense. La conversion entre les deux est simple, il suffit de multiplier par -1 (modulo 360 si tu veux un résultat positif).

Mais au final je n’ai pas compris si tu étais arrivé à quelque chose de fonctionnel ou si tu avais encore des soucis.

Ça fonctionne correctement maintenant avec mes derniers changements, mon soucis était que le résultat n’était pas optimisé avec cette fameuse condition pour la conversion.

orientationNSWE m’est donné, je ne peux pas modifier la valeur en entrée, à moins de faire la conversion sur elle mais ça déplacerait le problème ailleurs.