P. TRAU, Décembre 2006

Master IT1 - TP Génie Informatique n°3

Mettez vous à 2 par poste. Comme c'est notre dernier TP, vous me rendrez votre rapport dès la fin de la séance. Vous pouvez l'écrire à la main, ou me l'envoyer par mail , ou combiner les deux. Ce TP est inspiré du second contrôle de l'année dernière.

A) Description du modèle mathématique :

Pour analyser la cinématique des systèmes mécaniques plans, on peut utiliser différents outils mathématiques (vecteurs, torseurs, équations en projection sur x et y...). Il y en a une assez amusante qui consiste à utiliser des matrices dites "homogènes". Tout point (appartenant à une pièce en général) est défini par une matrice [3,1] (3 lignes, 1 colonne), contenant de haut en bas : sa coordonnée en x, en y, et la constante 1 (un). Tout mouvement d'une pièce est défini par une matrice [3,3] dont la dernière ligne est obligatoirement composée des constantes 0, 0, 1. Evidemment, il est inutile dans ce sujet de comprendre pourquoi on procède ainsi, il vous suffit de l'accepter.

Si une pièce bouge (mouvement ), alors tout point initialement en se retrouvera en tel que = * donc

Les matrices homogènes ont les particularités suivantes : l'application d'un mouvement à un point donne toujours un point (troisième ligne à 1), l'inverse d'une matrice homogène (inversible) est homogène, le produit de deux matrices homogènes (qui correspond à la composition de deux mouvements) est une matrice homogène :

La rotation d'un angle thêta d'une pièce, autour du point (0,0), a pour matrice .

La translation de c suivant x et de f suivant y a pour matrice .

La matrice Identité correspond à l'immobilisme (et est également homogène).

B) Mise en oeuvre informatique

Vous trouverez en annexe une définition de classes. Cette fois-ci, je ne vous demande pas de définir les classes, mais de les comprendre, les utiliser d'abord, les améliorer ensuite. Pour éviter de recopier l'annexe, vous pouvez rechercher sur internet le sujet de ce TP (à l'adresse www-ipst/program/genie-info, page où se trouvent tous les documents relatifs à ce cours).

Question 1 : expliquez (dans votre rapport) les caractéristiques des objets définis dans l'annexe. Pour les méthodes, vous expliquerez simplement ce qu'on donne, ce que ça rend, ce que ça fait. Réalisez un programme qui permette de vérifier le fonctionnement des différentes méthodes Le but n'est que celui donné dans la phrase précédente, il n'est pas question ici de vérifier si l'utilisateur (vous, d'ailleurs) est suffisamment bête pour taper des valeurs incohérentes. Montrez moi votre programme de test avant de passer à la question 2.

Question 2 : Pour effectuer une rotation autour d'un point (x,y) autre que le centre du repère, la méthode la plus simple est de déplacer la pièce de -x,-y puis effectuer la rotation autour de (0,0) puis déplacer de +x,+y. Rajoutez à la classe matrice un accesseur en écriture nommé "set_rot_gene" qui reçoive en argument un angle et un objet point, et réalise cette rotation. Vous utiliserez au maximum les méthodes déjà définies.

Question 3 : Pour un "point", définissez la méthode "bouger" qui reçoit en argument une matrice, et modifie le point actuel en lui appliquant la matrice.

Question 4 : Une pièce mécanique est représentée dans les programmes par des surfaces, des lignes, des volumes... mais tout cela s'appyant sur un ensemble de points (par exemple, un segment est défini par ses deux extrémités). Pour déplacer une pièce, il suffit de dépacer les points, sans rien changer au reste (par exemple, le segment reste un segment, il suffit de déplacer les deux extrémités). Créez une classe d'objets nommée "ens_points" qui possède comme attributs un entier nb donnant le nombre de points dans l'ensemble des points, et l'ensemble de ces points regroupés sous forme d'un tableau. Vous y adjoindres les méhodes : saisir, afficher, et bnouger (cette dernière reçoit en argument une matrice, et l'applique à tous les points de l'ensemble).

Question 5 : Un système mécanique est un ensemble de pièces mécaniques, reliées entre elles par des liaisons. Chaque liaison peut être représentée par une matrice (liaison = rotation ou translation ou combinaison ou identité pour la liaison complète) mais placée en un point donné. Vous allez donc me définir rapidement une classe "liaison", ayant pour attributs une matrice et un point, pour méthodes saisir et afficher. Vous pourrez ensuite essayer de mettre en oeuvre uune chaîne cinématique (c'est donc une suite de liasons).

Remarques : Comme vous l'avez remarqué, nous nous limitons aux systèmes mécaniques plans. Bien sûr, les matrices homogènes existent pour le 3D, les mécaniciens verrons surement cela (ou l'ont déjà vu), les IISA qui croient l'éviter vont être surpris par le cours de robotique. A partir de la question 2 nous avons des « interractions » entre les différentes classes. Dans la 2ème question, les matrices doivent connaître les points, c'est pourqoui j'ai déclaré les points avant les matrices. Dans la 3ème, ce sont les points qui doivent connaître les matrices, d'où la « déclaration anticipée ».

ANNEXE

//fichier tp3-classes.cpp
#include <iostream>
using namespace std;
#include <math.h>
class matrice; //pour pouvoir l'utiliser dans point, Q3

class point
 {
  float x,y;
 public:
  float get_x(void);
  float get_y(void);
  void set(float dx,float dy);
  void saisir(void);
  void afficher(void);
 };

class matrice
 {
  float a,b,c,d,e,f;
 public :
  void set(float da,float db,float dc,float dd,float de,float df);
  void set_rotation(float t);
  void set_translation(float dx,float dy);
  void set_identite(void);
  void saisir(void);
  void afficher(void);
  void produit(matrice A,matrice B);
 };

//les méthodes du point
float point::get_x(void)
 {return x;}
float point::get_y(void)
 {return y;}
void point::set(float dx,float dy)
 {x=dx;y=dy;}
void point::saisir(void)
 {cout<<"coordonnees du point ? ";
  cin>>x;
  cin>>y;
 }
void point::afficher(void)
 {cout<<"["<<x<<","<<y<<",1]";}

//les surcharges pour les points
ostream& operator << (ostream &f,point &v)
 {v.afficher(); return(f); }
istream& operator >> (istream &f,point &v)
 {v.saisir();  return(f); }

// les méthodes de la matrice
void matrice::set(float da,float db,float dc,float dd,float de,float df)
   {a=da;b=db;c=dc;d=dd;e=de;f=df;}
void matrice::set_rotation(float t)
   {a=cos(t);b=sin(t);c=0;d=-sin(t);e=cos(t);f=0;}
void matrice::set_translation(float dx,float dy)
   {a=1;b=0;c=dx,d=0;e=1;f=dy;}
void matrice::set_identite(void)
   {a=e=1;b=c=d=f=0;} //cette écriture simplifiée est autorisée en C++
void matrice::saisir(void)
  {float u,v;
   char rep;
   cout<<"type de matrice ? (I: ident, R: rot, T: transl, G:géné) ?";
   cin>>rep;
   if(rep=='I')set_identite();
   else if (rep=='R')
    { cout<<"angle (en rd) ?"; cin>>u; set_rotation(u); }
   else if (rep=='T')
    { cout<<"tx et ty ?"; cin>>u; cin>>v; set_translation(u,v); }
   else
    { cout<<"entrez les 6 coefs :"; 
      cin>>a; cin>>b; cin>>c; cin>>d; cin>>e; cin>>f; 
    }
  }
void matrice::afficher(void)
 {cout<<"["<<a<<","<<b<<","<<c<<"|"<<d<<","<<e<<","<<f<<"]";}

void matrice::produit(matrice A,matrice B)
   {
    a=A.a*B.a+A.b*B.d;
    b=A.a*B.b+A.b*B.e;
    c=A.a*B.c+A.b*B.f+A.c;
    d=A.d*B.a+A.e*B.d;
    e=A.d*B.b+A.e*B.e;
    f=A.d*B.f+A.e*B.f+A.f;
   }

//les surcharges pour les matrices
ostream& operator << (ostream &f,matrice &v)
 {v.afficher(); return(f); }
istream& operator >> (istream &f,matrice &v)
 {v.saisir();  return(f); }
matrice operator * (matrice v,matrice w)
 {matrice z; z.produit(v,w); return(z); }