Déplacement curviligne

Version imprimable

1 pièce(s) jointe(s)

Bonjour,

J'ai un exercice à faire où je dois faire une classe DeplacementCurviligne et où on représente ce déplacement le long d'un arc de cercle avec en attribut :
- le rayon de la courbe R (valeur positive ou nulle quand on tourne à gauche et négative quand on tourne à droite)
- et l'angle d'ouverture de l'arc en radian)
Munir cette classe d'un constructeur avec pour paramètres un rayon et un angle
Code:

1 2 3 4 5 6 7 8 9 public class DeplacementCurviligne extends Deplacement { private double rayon; private double angle; public DeplacementCurviligne(double rayon, double angle) { this.rayon = rayon; this.angle = angle; }
Je ne sais pas par où commencer en suivant l'annexe :
Pièce jointe 171119

Quelqu'un saurait-il me guider un peu ?

Merci d'avance pour votre aide.

08/03/2015, 19h52
joel.drigo

Salut,

Je suppose que dans Deplacement il y a une méthode qui doit être appelée successivement pour rendre le mouvement et qui doit renvoyer une coordonnée x,y : cette méthode doit être implémentée dans la classe DeplacementCurviligne pour qu'à chaque appel l'angle soit incrémentée (peut-être en fonction de paramètre genre vitesse angulaire et temps) et qui doit retourner la valeur du x et y pour le nouvel angle (selon les formules qui sont indiquées sur le croquis).

J'ai ça dans ma classe

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
public abstract class Deplacement {
	public abstract double longueur();
	public abstract Localisation extremite();
 
	protected Localisation appliquer(Localisation deport)
	{
		double d = Math.sqrt(extremite().x() * extremite().x() + extremite().y() * extremite().y());
		double phi = Math.cos(extremite().x()/d);
		if(phi < 0) phi = -phi;
		return (new (deport.x() + d * Math.cos(deport.theta() + phi), deport.y() + d * deport.theta() + phi));
	}
 
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Deplacement)) return false;
		Deplacement dep = (Deplacement) obj;
		double dl = longueur() - dep.longueur();
		return (dl * dl <= Localisation.EPS && extremite().equals(dep.extremite()));
	}
}

Je vois vraiment pas comment commencer ma classe

09/03/2015, 00h25
joel.drigo

Et il n'y a pas de doc pour expliquer ce que signifie ces attributs, méthodes et arguments de méthode (que veut bien pouvoir dire deport dans le contexte ?).

Je suppose que extremite est le point d'arrivée de déplacement, mais vu le nom, c'est loin d'être évident. Et longueur, serait-ce la distance de déplacement ? Si c'est le cas, il faudrait implémenter le calcul de la longueur de l'arc.

Ensuite appliquer() pourrait être cette méthode dont je parle, mais pourquoi est-elle déjà implémentée : son implémentation semble ( je dis semble parce que je ne comprends pas ce que vient faire dans la formule le théta du point deport) faire un déplacement du point passé en argument sur la distance entre le point extrémité et l'origine du répère, selon l'angle de la droite passant par extrémité et l'origine. Ce qui invalide l'hyptohèse que extrémité soit le point d'arrivée. Bref, c'est pas clair du tout cette classe. Surtout que la méthode ne compile pas : il manque le nom de la classe dans le return new ....

Pour programmer quelque chose, on a besoin de savoir ce qu'on manipule, et comment le manipuler.

[EDIT]Je pense comprendre ce que vient faire théta dans la formule : on parle d'un déplacement relatif. Donc on prend en compte la direction précédente de la Localisation, dont le nom n'est pas très adapté à ce qu'il signifie littéralement. Donc, en gros le point deport serait le point d'arrivée du déplacement précédent, portant l'angle de la direction du mobile en déplacement lorsqu'il se trouve au point deport.x, deport.y. La méthode appliquer transformerait un point de "localisation" en nouveau point de "localisation", selon le déplacement, dans ton cas, selon un arc de cercle. Mais pour le reste, c'est flou.
Du point de vue Java, je dirais qu'il faut redéfinir la méthode appliquer() et implémenter longueur() et extrémité(). Pour le reste, c'est des maths, et de la définition de la terminologie : rien à voir avec Java.

(x,y) est la position des points
(theta) est l'orientation

J'ai rectifié la classe Deplacement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public abstract class Deplacement 
{
	public abstract double longueur();
	public abstract Localisation extremite();
 
	protected Localisation appliquer(Localisation depart)
	{
		double d = Math.sqrt(extremite().x() * extremite().x() + extremite().y() * extremite().y());
		double phi = Math.cos(extremite().x()/d);
		if(phi < 0) phi = -phi;
		return (new Localisation(depart.x() + d * Math.cos(depart.theta() + phi), depart.y() + d * Math.cos(depart.theta() + phi), depart.theta() + phi));
	}
 
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Deplacement)) return false;
		Deplacement dep = (Deplacement) obj;
		double dl = longueur() - dep.longueur();
		return (dl * dl <= Localisation.EPS && extremite().equals(dep.extremite()));
	}
}

Malgré ton aide, je vois pas par ou commencer, je bloque ..

09/03/2015, 19h30
joel.drigo

Commence par implémenter les 2 méthodes abstraites (longueur() et extremite()) dans ta classe concrete (DeplacementCurviligne). Puis appliquer() pour que ça fasse le déplacement en question (donc que ça calcul en fonction de deport la nouvelle localisation (position et orientation)).

Sur les annexes que j'ai mis en haut, il y a l = R.α. Du coup est-ce que je passe des paramètres pour les définir le Rayon et l'angle ?

[EDIT]
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public abstract class DeplacementCurviligne extends Deplacement { private double rayon; private double angle; public DeplacementCurviligne(double rayon, double angle) { this.rayon = rayon; this.angle = angle; } public double longueur() { return(angle * rayon); } }
?

On te donne ça :
Code:

1 2 3 4 5 6 7 8 9 public class DeplacementCurviligne extends Deplacement { private double rayon; private double angle; public DeplacementCurviligne(double rayon, double angle) { this.rayon = rayon; this.angle = angle; }
Il faut que tu ajoutes à cette classe :
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 public double longueur() { ... return ... } public Localisation extremite() { ... return ... } protected Localisation appliquer(Localisation depart) { ... return ... } }
Les ... sont à remplacer par le code qui fait ce que la méthode doit faire : donc, par exemple, pour longueur de l'arc, à priori, la formule étant effectivement bien R × α, avec α en radians, soit le rayon multiplié par l'angle, tu implémentes la méthode longueur pour qu'elle retourne le produit des deux variables de la classe qui servent à stocker rayon et angle.

Code:

1 2 3 4 5 6 7 8 9 public double longueur() { return(rayon * angle); } public Localisation extremites() { return(new Localisation(rayon * Math.sin(angle), rayon * (1 - Math.cos(angle), angle * ))) }
J'ai un petit problème, pour x j'ai |R| * α, comment faire le |R| ? Et pour theta j'ai α * signe(R). Je ne sais pas à quoi correspond signe ??

09/03/2015, 20h04
joel.drigo

J'avais pas vu cette histoire de signe. On te dit dans l'énoncé que le signe du rayon représente la direction : à gauche ou à droite. Il faut le mettre de côté dès le début dans le constructeur, pour ne garder que la valeur absolue du rayon (un rayon c'est une distance, c'est forcément positif, donc stocke dans le rayon une valeur positive (par exemple Math.abs(rayon), et pour le signe Math.signum(rayon)). Ensuite, tu utiliseras ce signe pour orienter le mouvement (mais il n'entre pas en compte dans le calcul de la longueur).
09/03/2015, 20h08
simonmnt

Je ne vois pas comment utiliser ces deux méthodes que tu me donne dans mon constructeur ..

Les formules que tu as sur le croquis traduites en Java donnent :
Code:

1 2 3 x = Math.abs(rayon) * Math.sin( angle ); y = rayon * ( 1 - Math.cos( angle ) ); theta = angle * Math.signum( rayon );
n'est-ce-pas ?

(bon, ce qui me semble étonnant, c'est que l = rayon * angle, alors que rayon peut-être négatif, mais bon peut-être que l, ce n'est pas une distance...)

Donc tu peux utiliser ces "formules" de calcul Java pour faire ton déplacement, mais tu peux également préparer dans le constructeur tes variables pour éviter d'avoir à faire ce calcul :
Code:

1 2 3 4 5 6 7 8 9 10 public class DeplacementCurviligne ... ... private double signe; public DeplacementCurviligne(double rayon, double angle) { this.rayon = Math.abs(rayon); this.signe = Math.signum(rayon); this.angle = angle; }
Et donc avoir les formules comme ça :
Code:

1 2 3 x = rayon * Math.sin( angle ); y = signe * rayon * ( 1 - Math.cos( angle ) ); theta = angle * signe;
Après c'est toi qui vois quelle solution tu vas utiliser...

09/03/2015, 21h13
simonmnt

Super, c'est cette histoire de signe que j'avais un peu de mal, merci de ton aide. Et non l n'est pas la distance mais la longueur du déplacement.
09/03/2015, 21h20
joel.drigo

Citation:

Envoyé par simonmnt

Et non l n'est pas la distance mais la longueur du déplacement.

Bah, c'est pareil : la longueur d'un segment, c'est la distance entre les extrémités... c'est sûr que pour un arc, on ne peut plus parler de distance, mais, enfin, le problème n'est pas dans la définition de distance ou de longueur, mais dans le fait que la longueur est négative... moi je ne connais pas une longueur négative (y' a bien la norme d'un vecteur, mais ça n'a rien à voir à priori, surtout dans le contexte d'un arc), mais je ne suis mathématicien, je suis développeur informatique : donc peut-être qu'une longueur négative ça existe...
09/03/2015, 21h21
simonmnt

Citation:

Envoyé par joel.drigo

Bah, c'est pareil : la longueur d'un segment, c'est la distance entre les extrémités... c'est sûr que pour un arc, on ne peut plus parler de distance, mais, enfin, le problème n'est pas dans la définition de distance ou de longueur, mais dans le fait que la longueur est négative... moi je ne connais pas une longueur négative, mais je ne suis mathématicien, je suis développeur informatique : donc peut-être qu'une longueur négative ça existe...

Va savoir .. En tout cas merci !
09/03/2015, 21h26
joel.drigo

ça peut avoir quand même son importance : si cette méthode longueur() sert à déterminer la distance parcourue (pour le coup, on parle bien de distance), si on fait la somme de toutes les longueurs de toutes les instances de Deplacement, et qu'il y en a des négatives, le total sera faux. Je dis ça, je dis rien :P