calcul distance coordonnées dans un array

Bonjour,

J'aimerais calculer la distance entre des coordonnées x et y. Mes coordonnées sont stockées dans un array.

Comment dois-je m'y prendre pour calculer une distance?

J'essaie de commencer mais je bloque bien vite

1
2
3
4
5
6

function distancePoint(){
    var myArray = [[5,7],[5,8],[2,8]];
    for (var i = 0; i < myArray.length; i++) {
        for (var j = 0; j < myArray[i].length; j++) {
        }
}

J'ai pas compris. Tu veux calculer la distance entre chaque points ? Par quelle distance, euclidienne ? Ou tu veux juste faire la différence entre les valeurs en x et en y, ce qui n'a aucun sens géométrique ?

C'est vrai que c'est pas très clair. Je t'explique d'avantage

j'ai trois coordonnées qui stockées dans mon array myArray = [[5,7],[5,8],[2,8]];

Je veux créer une fonction qui renvoie la distance correspondant au parcours entre tous ces points. Ici par exemple, entre le premier et le dernier point il parcourt 4 "cases" (1 case entre le premier et le deuxième point et 3 cases entre le troisième et le dernier point).

C'est plus clair?

La vache, j'étais à douze mille lieux de penser à faire ça avec Pythagore. je vais essayer de l'exprimer en code mais ça me paraît hardos d'un seul coup.

est-ce que tu peux me mettre sur la piste pour le code parce que là je sèche complètement.

Vous en pensez quoi? C'est pas très propre quand même non?

Ce serait mieux si je mettais une boîte dialogue ou l'utilisateur peut rentrer des coordonnées et que ma fonction calcule les distances à chaque fois.

Je vais faire ça

C'est assez sale comme méthode, si tu as 4 points au lieu de 3 comment vas-tu faire ?

Pourquoi ne pas utiliser un objet de type point ? Ensuite faire une liste de points ?

Oui je suis d'accord c'est assez sale.

Pour rajouter un point, je duplique simplement ce que j'ai déjà fait.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

function lineDistance(x1, y1, x2, y2, x3, y3) {

  xs = x2 - x1;
  xs = xs * xs;

  ys = y2 - y1;
  ys = ys * ys;

  xs = x3 - x2;
  xs = xs * xs;

  ys = y3 - y2;
  ys = ys * ys;

return Math.sqrt( xs + ys );

}

console.log(lineDistance(5,7,5,8,2,8));

Qu'est-ce qu'un objet de type point?

Ton calcul est faux. Change x1, tu verras que le résultat final ne change pas…

Voici un exemple :

1
2
3
4
5

function Point (x,y) {
    this.x = x;
    this.y = y;
     ...
}

ça aurait une structure de base comme ça donc

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

function Point() {
    this.x = x
    this.y = y
}

Robot.prototype.distanceCoordinates = function() {

    console.log(lineDistance());
}

var points = [
    new Point([5,7]),
    new Point([5,8]),
    new Point([2,8])
];

points.forEach(function(point)) {
    point.distanceCoordinates();
}

Oui c'est déjà beaucoup mieux !

ok mais je bloque là

j'ai du mal à tout remettre en ordre pour que cela fonctionne

Qu'est ce qui te bloque ?

l'opération à mettre dans mon prototype, j'ai du mal à l'exprimer en moins crado que ce que je n'ai fait.

Si tu parles de ta fonction distanceCoordinates() il faut la généraliser.

Elle doit calculer la distance entre deux points, combien de paramètres a-t-elle besoin ? !

Je me demande même si on ne pourrait pas utiliser la récursivité ? !

Salut Moody_jr,

As-tu trouvé une solution à ton algorithme finalement ?

Je n'ai aucune compétence en Javascript, donc voici l'implémentation que j'aurais fait en Python. La syntaxe reste très accessible même si tu ne connais pas ce langage.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

import math

class Point() :
    def __init__(self, x, y) :
        self.x = x
        self.y = y

def getDist(start_point, end_point) :
""" Calcule la distance euclidienne entre deux points (formule fournie précédemment par Kje)"""
    return math.sqrt((end_point.x - start_point.x)**2 + (end_point.y - start_point.y)**2)

# coordinates est une liste d'objet "Point", que tu initialises avec leur valeurs en abscisses et en ordonnées
coordinates = [Point(0,0), Point(0,1), Point(0,2), Point(0,3)]

dist = 0 #Variable qui stockera la distance totale

for i in range(1,len(coordinates)) : #Pour i de 1 à n-1 (n étant le nombre d'éléments de la liste)
    dist += getDist(coordinates[i-1], coordinates[i])

print(dist)

Si quelqu'un a une autre méthode de calcul, ça m'intéresse