Calcul de moyenne sur 360°

Version imprimable

Bonjour,
Je viens demander des pistes car j'ai le cerveau en ébullition ...
Je cherche à mettre en place une moyenne entre 2 valeurs sur 360° avec passage par le 0°
ex: (270° + 90°) / 2 = 0° ou encore (90° + 270°) / 2 = 0°, etc ...

J'arrive à gérer le "nord" avec cette fonction:
Code:

1 2 3 4 5 6 7 8 9 10 11 var btwm = 270; var btw_prec = 90; function north (btmw,btw_prec) { if (btwm - btw_prec > -180 | btwm - btw_prec < 180) { return (((btwm + btw_prec) / 2) + 180 ) % 360; } else if (btwm - btw_prec > 180 | btwm - btw_prec < -180){ return (((btwm + btw_prec) / 2) + 360 ) % 360; } }; console.log('function north='+north(btwm,btw_prec));
donc cool ;) mais le calcul simple, ex: (0° + 180°) / 2= 90° ou (225° + 225°) / 2 = 225°, ne fonctionne pas du tout

J'arrive à faire fonctionner soit le calcul classique de moyenne mais le passage par le 0° est en vrac soit le passage par le nord est bon et le calcul classique est en vrac ... jamais les 2 en même temps ...

Si vous avez une solution je suis preneurcar là je tourne en rond ...

Merci

Code:

1
2
3
4
//(x + y)%360 / 2
(225 + 225)%360 / 2; //45
(0 + 180)%360 / 2; //90
(270 + 270)%360 / 2; //90

comme ca ?

14/02/2018, 15h56
rlelamer

bonjour Doksuri,

Heu nan

(270 + 270) / 2 =270; (225 + 225) / 2 = 225 en revanche c'est bon pour (0 + 180) / 2 = 90

C'est une moyenne entre les 2 valeurs sauf que j'ai la contrainte d'être limité à 360° et que la plage de la moyenne ne doit pas excéder 180°

ex : (0 + 180) / 2 = 90° mais (0 + 182) / 2 = 271°

Le faire à la main ou de tête est relativement facile, l'informatiser ne l'est pas du tout ... et je n'ai pas qu'une ligne à traiter sinon je ne poserais pas la question ( quoique histoire de gagner du temps ;) )
14/02/2018, 17h12
Doksuri

je ne comprends pas l'enonce de ta problematique :
"la plage de la moyenne ne doit pas excéder 180°"
=> pourtant tu donnes en exemple (0 + 182) / 2 = 271° (donc superieur a 180)
de plus, je ne comprends pas comment 182 / 2 serait egal a 271. 91 j'aurai compris, mais 271... c'est de l'autre cote :koi:

Effectivement c'est pas évident à comprendre ;)

Je vais tenter de m'expliquer mieux que précédemment

En navigation maritime, si suis le cap magnétique 0°, donc le Nord, je pars du principe que je peux avoir au maximum 2 limites de cap possible soit 90° à droite ou 90° à gauche soit 180°

J'ai des instructions de changements de cap ( HDG = Heading ) à suivre, en calculant une moyenne je 'lisse' ces instructions ce qui me permet de suivre un cap moyen qui m'emmènera à bon port ( je ne parle pas de vitesse et autre juste de cap moyen )
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 var btwm = 270; var btw_prec = 0; function north (btw_prec,btwm) { if (btw_prec === btwm) { return ((btw_prec + btwm) / 2) % 360; } else if (btw_prec - btwm > 0 && btw_prec > 180) { return (((btw_prec + btwm) / 2) + 180) % 360; } else if (btw_prec - btwm > 0 && btw_prec < 180) { return (((btw_prec + btwm) / 2) + 360) % 360; } else if (btw_prec - btwm < 0 && btwm > 180) { return (((btw_prec + btwm) / 2) + 180) % 360; } else if (btw_prec - btwm < 0 && btwm < 180) { return (((btw_prec + btwm) / 2) + 360) % 360; } }; console.log(north(btw_prec,btwm));
Normalement tous les tests possibles et imaginables retournent le bon cap lissé
En revanche des que btwm et btw_prec prennent les valeurs 0° et 180° ou 180° et 0° la fonction plante ... :weird:

Citation:

Envoyé par Doksuri

(0 + 182) / 2 = 271° (donc supérieur a 180)
de plus, je ne comprends pas comment 182 / 2 serait egal a 271. 91 j'aurai compris, mais 271... c'est de l'autre cote :koi:

Si je navigue au 0 et qu'on me demande d'aller au 182 la moyenne est bien 271, comme je dépasse les 180° je passe sur l'autre coté

:salut:

Dans le cas ou l'on mesure la direction du vent à partir de l'angle d'une girouette (dans le sens horaire), une moyenne arithmétique n'est pas la solution (car on peut obtenir comme moyenne une direction inverse au sens du vent).

Il faut considérer le problème du point de vue du cercle trigonométrique (sin et cos de l'angle en radian). La pointe de la girouette étant sur le cercle trigonométrique.

On peut avoir une moyenne entre deux ou plusieurs mesures !

Voici ma méthode et mes tests de calcul :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
{ // cas 0 et 182
	const
		anglesMesuré = [ 0, 182 ],
		converDegEnRadian = Math.PI / 180.0,
		converRadianEnDeg = 180.0 / Math.PI;
 
	let
		arX = [],
		arY = [],
		sommeX = 0.0,
		sommeY = 0.0,
		moyenneX = 0.0,
		moyenneY = 0.0,
		angleMoyen = 0.0;
 
	for ( const [ i, angle ] of anglesMesuré.entries() ){
		arX[ i ] = Math.cos( angle * converDegEnRadian );
		arY[ i ] = Math.sin( angle * converDegEnRadian );
	}
 
	for ( const value of arX ){
		sommeX += value;
	}
 
	moyenneX = sommeX / arX.length;
 
	for ( const value of arY ){
		sommeY += value;
	}
 
	moyenneY = sommeY / arY.length;
 
	angleMoyen = Math.atan2( moyenneY, moyenneX ) * converRadianEnDeg;
 
	if ( angleMoyen < 0 ){
		angleMoyen += 360;
	}
 
	console.log( `L'angle moyen du vent est de ${angleMoyen}°` );
	// L'angle moyen du vent est de 270.99999999999994°
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
{ // cas 0 et 180
	const
		anglesMesuré = [ 0, 180 ],
		converDegEnRadian = Math.PI / 180.0,
		converRadianEnDeg = 180.0 / Math.PI;
 
	let
		arX = [],
		arY = [],
		sommeX = 0.0,
		sommeY = 0.0,
		moyenneX = 0.0,
		moyenneY = 0.0,
		angleMoyen = 0.0;
 
	for ( const [ i, angle ] of anglesMesuré.entries() ){
		arX[ i ] = Math.cos( angle * converDegEnRadian );
		arY[ i ] = Math.sin( angle * converDegEnRadian );
	}
 
	for ( const value of arX ){
		sommeX += value;
	}
 
	moyenneX = sommeX / arX.length;
 
	for ( const value of arY ){
		sommeY += value;
	}
 
	moyenneY = sommeY / arY.length;
 
	angleMoyen = Math.atan2( moyenneY, moyenneX ) * converRadianEnDeg;
 
	if ( angleMoyen < 0 ){
		angleMoyen += 360;
	}
 
	console.log( `L'angle moyen du vent est de ${angleMoyen}°` );
	// L'angle moyen du vent est de 90°
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
{ // cas 225 et 225
	const
		anglesMesuré = [ 225, 225 ],
		converDegEnRadian = Math.PI / 180.0,
		converRadianEnDeg = 180.0 / Math.PI;
 
	let
		arX = [],
		arY = [],
		sommeX = 0.0,
		sommeY = 0.0,
		moyenneX = 0.0,
		moyenneY = 0.0,
		angleMoyen = 0.0;
 
	for ( const [ i, angle ] of anglesMesuré.entries() ){
		arX[ i ] = Math.cos( angle * converDegEnRadian );
		arY[ i ] = Math.sin( angle * converDegEnRadian );
	}
 
	for ( const value of arX ){
		sommeX += value;
	}
 
	moyenneX = sommeX / arX.length;
 
	for ( const value of arY ){
		sommeY += value;
	}
 
	moyenneY = sommeY / arY.length;
 
	angleMoyen = Math.atan2( moyenneY, moyenneX ) * converRadianEnDeg;
 
	if ( angleMoyen < 0 ){
		angleMoyen += 360;
	}
 
	console.log( `L'angle moyen du vent est de ${angleMoyen}°` );
	// L'angle moyen du vent est de 225°
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
{ // cas 90 et 270
	const
		anglesMesuré = [ 90, 270 ],
		converDegEnRadian = Math.PI / 180.0,
		converRadianEnDeg = 180.0 / Math.PI;
 
	let
		arX = [],
		arY = [],
		sommeX = 0.0,
		sommeY = 0.0,
		moyenneX = 0.0,
		moyenneY = 0.0,
		angleMoyen = 0.0;
 
	for ( const [ i, angle ] of anglesMesuré.entries() ){
		arX[ i ] = Math.cos( angle * converDegEnRadian );
		arY[ i ] = Math.sin( angle * converDegEnRadian );
	}
 
	for ( const value of arX ){
		sommeX += value;
	}
 
	moyenneX = sommeX / arX.length;
 
	for ( const value of arY ){
		sommeY += value;
	}
 
	moyenneY = sommeY / arY.length;
 
	angleMoyen = Math.atan2( moyenneY, moyenneX ) * converRadianEnDeg;
 
	if ( angleMoyen < 0 ){
		angleMoyen += 360;
	}
 
	console.log( `L'angle moyen du vent est de ${angleMoyen}°` );
	// L'angle moyen du vent est de 180°
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
{ // cas angles divers
	const
		anglesMesuré = [ 0, 90, 180, 45, 125 ],
		converDegEnRadian = Math.PI / 180.0,
		converRadianEnDeg = 180.0 / Math.PI;
 
	let
		arX = [],
		arY = [],
		sommeX = 0.0,
		sommeY = 0.0,
		moyenneX = 0.0,
		moyenneY = 0.0,
		angleMoyen = 0.0;
 
	for ( const [ i, angle ] of anglesMesuré.entries() ){
		arX[ i ] = Math.cos( angle * converDegEnRadian );
		arY[ i ] = Math.sin( angle * converDegEnRadian );
	}
 
	for ( const value of arX ){
		sommeX += value;
	}
 
	moyenneX = sommeX / arX.length;
 
	for ( const value of arY ){
		sommeY += value;
	}
 
	moyenneY = sommeY / arY.length;
 
	angleMoyen = Math.atan2( moyenneY, moyenneX ) * converRadianEnDeg;
 
	if ( angleMoyen < 0 ){
		angleMoyen += 360;
	}
 
	console.log( `L'angle moyen du vent est de ${angleMoyen}°` );
	// L'angle moyen du vent est de 86.97433531874515°
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
{ // cas angles divers
	const
		anglesMesuré = [ 276, 271, 270, 273, 274, 277 ],
		converDegEnRadian = Math.PI / 180.0,
		converRadianEnDeg = 180.0 / Math.PI;
 
	let
		arX = [],
		arY = [],
		sommeX = 0.0,
		sommeY = 0.0,
		moyenneX = 0.0,
		moyenneY = 0.0,
		angleMoyen = 0.0;
 
	for ( const [ i, angle ] of anglesMesuré.entries() ){
		arX[ i ] = Math.cos( angle * converDegEnRadian );
		arY[ i ] = Math.sin( angle * converDegEnRadian );
	}
 
	for ( const value of arX ){
		sommeX += value;
	}
 
	moyenneX = sommeX / arX.length;
 
	for ( const value of arY ){
		sommeY += value;
	}
 
	moyenneY = sommeY / arY.length;
 
	angleMoyen = Math.atan2( moyenneY, moyenneX ) * converRadianEnDeg;
 
	if ( angleMoyen < 0 ){
		angleMoyen += 360;
	}
 
	console.log( `L'angle moyen du vent est de ${angleMoyen}°` );
	// L'angle moyen du vent est de 273.5°
}

15/02/2018, 08h03
rlelamer

Bonjour danielhagnoul,

Tout d'abord merci d'avoir mis en avant mon erreur, je n'avais pas du tout pensé à cette manière d'approcher le calcul de la moyenne, qui avec du recul semble effectivement bien plus logique que mon bricolage ...
Il me faut du coup revoir un autre calcul, celui de l'angle au vent ( TWA - True Wind Angle ) dont tu parles ici, et j'appliquerais la même méthode pour le cap magnétique ( HDG - Heading )

Merci pour tes lumières et ton code ;)
15/02/2018, 22h42
Watilin

J’aimerais rajouter qu’il faut se poser la question de la pertinence de certaines données.
Si tu reçois deux instructions HDG exactement contraires (par exemple, 0 et 180), la meilleure façon de s’approcher des deux destinations à la fois est… De ne pas bouger :P
16/02/2018, 01h09
danielhagnoul

Citation:

Envoyé par Watilin

J’aimerais rajouter qu’il faut se poser la question de la pertinence de certaines données.
Si tu reçois deux instructions HDG exactement contraires (par exemple, 0 et 180), la meilleure façon de s’approcher des deux destinations à la fois est… De ne pas bouger :P

:ptdr:
18/02/2018, 23h50
rlelamer
@danielhagnoul, bonsoir

J'ai rencontré un petit soucis avec le calcul de l'angle moyen que j'ai résolu en ajoutant un Math.round ( variable * 10) / 10

Code:

angleMoyen = Math.atan2( moyenneY, moyenneX ) * converRadianEnDeg;

par

Code:

angleMoyen = Math.round( ( Math.degrees( Math.atan2( moyenneY, moyenneX ) ) * 10) ) / 10;

Des fois il me donnait 0° [271, 89], d'autres fois -4.559511842771973e-14° [274 , 86]

# Math.degrees ( c'est la même chose que converRadianEnDeg )
Code:

1 2 3 Math.degrees = function (radians) { return radians * 180.0 / Math.PI; }
J'ai une question :
Si tu as un tableau comme celui ci
http://img1.imagilive.com/0218/Captu...8_a_231839.png
( Ne pas se fier aux valeurs TWAm et BTWm certaines sont fausses ... )

TWAm ( True Wind Angle moyen ) correspond à la moyenne de l'angle au vent et BTWm (Bearing To Waypoint moyen) correspond à la moyenne du cap

J'ai besoin de prendre en compte les itérations de 10 min pour calculer correctement les moyennes TWA par exemple ( colonne TWAm )
De T +0:00 à T +0:10, l'itération existe donc je peux faire le calcul ( il faut être au 143 en TWA pour atteindre le point T +0:10 à partir de T +0:00 )
De T +0:00 à T +0:40, certaines itérations ne sont pas listé, il me faut donc les prendre en compte
T +0:00 -> 143 ( existe )
T +0:10 -> 143 ( existe )
T +0:20 -> 143 ( n'existe pas )
T +0:30 -> 143 ( n'existe pas )
T +0:40 -> 140

Donc pour atteindre T +0:40 à partir de T +0:00, revient à prendre en compte les 4 valeurs 143 pour angleMesuré dans ta fonction et ainsi de suite pour les autres lignes

Comment je peux mettre ça en oeuvre dans ta fonction ?

Merci d'éclairer ma lanterne
19/02/2018, 01h01
danielhagnoul

Eh oui, 0 et -4e-14 c'est très différent ! :aie:
Je ne me suis pas occupé des problèmes d'arrondis, en effet.

On peut toujours ajouter des valeurs à un Array : [ 143, 143, 143, ... ] mais dupliquer la dernière valeur pour remplacer les valeurs manquantes introduira certainement une erreur dont l'importance m'échappe, car je ne connais rien aux problèmes de navigation. Je ne sais pas vous conseiller sur ce qu'il faut faire ou ne pas faire pour obtenir un résultat correct.