La distance la plus courte entre deux degrés, les marques sur un cercle?

Je suis à la recherche d'une formule pour trouver la distance la plus courte en degrés entre les deux degrés, les marques sur un cercle: par exemple, 30 degrés et 170 degrés (140 degrés).

Les deux degrés, les marques peuvent être pratiquement n'importe quel nombre réel, et n'est pas nécessairement compris entre 0 et 360 (peut être négatif, ou beaucoup plus que la 360, par exemple -528.2 et 740 (qui est 171.8 degrés)). Toutefois, cette distance doit toujours être <= 180 degrés et >= 0 degrés.

Il semble assez simple. Mais, j'ai essayé de trouver une bonne solution et j'ai essayé beaucoup de code, mais rien de ce que j'ai trouvé pour l'instant fonctionne dans tous les cas, j'ai essayé. Je travaille en c++. Quelqu'un a une idée?

abs(deg1 - deg2) vous donnera la différence, et puis une simple modulo mathématiques à la faire < 180 à tout moment devrait faire l'affaire.
Il semble que vous prendre la valeur absolue de ces deux numéros, et soustraire le plus petit du plus grand, basée sur des exemples.
qui ne fonctionne pas. Imaginez le point de départ étant à 90. Couvrant les 4 points que vous avez -90 (aka 270), 0, 90 et 180. Si vous avez un point à -90 et l'autre à 135 alors que la distance minimale entre eux est en fait 135.
Oui, j'ai réalisé que vous avez besoin d'un module de calcul.

OriginalL'auteur Joe Lyga | 2012-02-29

  1. 20

    • Étape 1: Obtenir le "raw" de différence. Par exemple, étant donné -528.2 et 740.0, c'est 1268.2.

      • : raw_diff = first > second ? first - second : second - first
      • d'une autre manière: raw_diff = std::fabs(first - second)

    • Étape 2: Soustraire un multiple de 360.0 pour obtenir une valeur comprise entre 0.0 (inclus) et 360.0 (exclusif).

      • mod_diff = std::fmod(raw_diff, 360.0)

    • Étape 3: Si cette valeur est supérieure à 180.0, de la soustraire 360.0.

      • : dist = mod_diff > 180.0 ? 360.0 - mod_diff : mod_diff
      • d'une autre manière: dist = 180.0 - std::fabs(mod_diff - 180.0)

    C'est probablement la plus lisible comme une série de déclarations:

    double raw_diff = first > second ? first - second : second - first;
double mod_diff = std::fmod(raw_diff, 360.0);
double dist = mod_diff > 180.0 ? 360.0 - mod_diff : mod_diff;

    Mais si vous le souhaitez, il n'est pas difficile de mettre tout cela en une seule expression:

    180.0 - std::fabs(std::fmod(std::fabs(first - second), 360.0) - 180.0)
    Cela fonctionne très bien. Pourrait-il être modifié pour renvoyer un négatif de la distance la plus courte distance entre la première et la seconde est dans le sens antihoraire et un nombre positif si c'est dans le sens horaire?
    Qui peut être fait, mais il est plus grand que celui qui entre dans un commentaire.

    OriginalL'auteur ruakh

  2. 2

    Vous pourriez aussi utiliser un vecteur de maths et trigonométrie; angles en radians ici.

    float angle(float angle1, float angle2)
{
  float x1=cos(angle1);
  float y1=sin(angle1);
  float x2=cos(angle2);
  float y2=sin(angle2);

  float dot_product = x1*x2 + y1*y2;
  return acos(dot_product);
}
    C'est mathématique, mais de calcul intensif, et génère beaucoup de inutile erreur d'arrondi. Un fabs+fmod approche de pistes environ 20 fois plus rapide et génère des ordres de grandeur de moins arrondi.
    En outre, vous pouvez utiliser une identité trigonométrique: (sin(a)sin(b)+cos(a)cos(b) = sin(a-b) pour dériver la solution: acos(sin(angle1 - angle2)).
    sin(a)sin(b)+cos(a)cos(b) cos(a-b), pas sin(a-b). Voir ici.

    OriginalL'auteur tmpearce

  3. 0

    Vous devez importer la bibliothèque de mathématiques bien sûr, pour fmod et fab.

    double a = -528.2;
double b = 740.0;
double diff = (a > b ? a - b : b - a);
double mod_diff = fmod(diff, 360);
double result = (mod_diff < 180 ? mod_diff : 360 - mod_diff);
    Ce n'est pas tout à fait droit. Si (par exemple) a est 0 et b est 200, votre code vous donnera 20 plutôt 160.
    Oh oui, hmm, laissez-moi voir ici ...
    Merci pour la réponse, mais j'ai trouvé un contre-exemple. Dire que a = 10 et b = 270. a est inférieur à b, donc la réponse serait (270 - 10) mod 180. Mais 260 mod 180 80, mais la distance réelle est de 100.
    Là, nous allons, je l'ai fait (honte sur moi) testé ce code et maintenant il me donne 171.8 pour le résultat.
    Et fonctionne également pour a=10, b=270, résultat=100. Et se comporte correctement avec un & b commuté.

    OriginalL'auteur Prashant Kumar

  4. 0

    Vous pouvez appliquer la formule que vous trouverez ici ( http://en.wikipedia.org/wiki/Arc_(géométrie) ) sur les angles et sur les deux directions.
    Si vous trouvez la complémentarité de deux distances (si vous les résumer, vous obtiendrez la circonférence (ou vous pouvez obtenir la longueur d'un arc en soustrayant la longueur de l'autre de l'arc de la circonférence).

    Vous pouvez ensuite comparer les deux longueurs pour obtenir la distance minimale entre deux points différents angles.

    En C++, vous avez les mathématiques.h bibliothèque: http://www.cplusplus.com/reference/clibrary/cmath/

    Hmm, c'est une bonne idée.
    de l'essayer. je vous suggère de le faire sur papier d'abord, puis l'implémenter en C++.

    OriginalL'auteur

  5. 0

    J'ai eu un problème similaire pour trouver

    • Distance la plus courte à partir de n'importe quel point à n'importe quel point dans un cercle.
      J'ai obtenu la solution comme suit:

    si N = nombre de points dans le cercle

                    0 -> N-1
        j before n/2 after (n-j)

               1 -> N-1
   (j-1) before [(n/2)+1] after n-j+1

               2 -> N-1
   (j-2) before [(n/2)+2] after n-j+2

               and so on

    où j est deuxième point et je est premier point

    Ici peu de code python pour la solution.

    for i in range(0, n):
   for j in range(i,n):
          if j < n/2+i:
                 s_rt = j-i
          else :
                 s_rt = n-j+i

    Je pense que cela peut être utilisé pour trouver la solution en faisant un léger ajustement de degré.

    OriginalL'auteur Gopi Shankar

  6. 0

    J'avais été à la recherche d'une solution à base de microcontrôleur de ce genre pour boîte de vitesses à la recherche d'un animatronique marionnette et je n'ai pas eu le grognement de calculer trig correctement.

    @ruakh réponse était une bonne base, mais j'ai trouvé une condition d'erreur dans @laggyluk de la signature de la modification (Ajout d'un signe pour indiquer la direction) dans les commentaires (c'est l'été supprimée depuis). Plus précisément, le signe a été renversé dans certaines conditions.

    Voici la solution qui a fonctionné pour moi. Cette solution fonctionne pour le degré de repères dans un cercle, mais en changeant MAX_VALUE permet de travailler pour un arbitraire portée max (utile lors de la mesure des engins de codeur d'impulsions).

    Testé sur Ardunio. Formaté pour des raisons de lisibilité.

    #define MAX_VALUE 360

float shortestSignedDistanceBetweenCircularValues(float origin, float target){

  float signedDiff = 0.0;
  float raw_diff = origin > target ? origin - target : target - origin;
  float mod_diff = fmod(raw_diff, MAX_VALUE); //equates max/min boundaries. E.g 0 == 360 degrees in circle

  if(mod_diff > (MAX_VALUE/2) ){
    //There is a shorter path in opposite direction
    signedDiff = (MAX_VALUE - mod_diff);
    if(target>origin) signedDiff = signedDiff * -1;
  } else {
    signedDiff = mod_diff;
    if(origin>target) signedDiff = signedDiff * -1;
  }

  return signedDiff;

}

    OriginalL'auteur Luke Mcneice

  7. -1

    Vous pouvez essayer d'obtenir la valeur absolue de la différence des restes de deux angles lorsqu'il est divisé par 360.

    #include <iostream>
#include <cmath>

using namespace std;
int degree_difference(int a, int b)
{
    return abs(a%360-b%360);
}

int main()
{
    int result = degree_difference(-235, 15);
    cout << "Difference: " << result << endl;
    return 0;
}
    Pardon, je ne pense pas que ce est ce que vous voulez.

    OriginalL'auteur enderskill

  8. -1

    Nous devons présumer qu'un seul cercle a 360 degrés, sinon il va devenir difficile.

    Donc, la première chose que vous avez à faire est d'obtenir chaque note de 0 à 360. Pour ce faire, vous pouvez prendre le module de marque à la fois par 360. Si le montant est inférieur à 0, puis ajouter 360.

    Disons que nos points de 520 et -45.

    mark1 = ((520 % 360) >= 0) ? (520 % 360) : 360 - (520 % 360);

mark2 = ((-45 % 360) >= 0) ? (-45 % 360) : 360 - (-45 % 360);

    mark1 sera de 160. marque 2 315.

    Maintenant, il vous suffit de prendre la valeur absolue de la différence:

    result = abs(mark1 - mark2) = 155

    OriginalL'auteur NotMe