Le but de ce projet est de proposer une bibliothèque regroupant différents objets géométriques utilisés en mathématiques : repère, point, droite, cercle, courbe... afin de faciliter l'écriture de logiciels de géométrie dynamique.
Je présente ici trois bibliothèques adaptées à des environnements différents. Ces bibliothèques et les exemples qui les accompagnent ont été testés sous Linux, distribution Ubuntu.
L'environnement GTK+/GDK/cairo ne nécessite pas de programmation objet d'où l'idée de créer une bibliothèque en langage C. Les exemples utilisant cette bibliothèque sont aussi en C mais c'est au prix d'une mise au point un peu plus compliquée que dans les autres environnements.
Les deux autres bibliothèques écrites en C++ sont plus adaptées au monde des objets géométriques. La seule différence entre ces deux dernières bibliothèques porte uniquement sur la méthode appelée trace qui a pour rôle de représenter les objets géométriques à l'écran. Dans l'environnement Qt les tracés se font sur un Qpainter, dans l'environnement cairo, les tracés se font sur un cairo. Ainsi sous cairo on écrira : trace (cairo *cr) et sous Qt on écrira : trace (Qpainter *painter).
La phase de préparation des exemples et la compilation sont un peu plus compliquées sous Qt mais la bibliothèque Qt étant beaucoup plus homogène et de type POO, l'écriture des différents exemples s'avère finalement plus agréable que sous l'environnement GTK+/GDK/cairo. Des trois techniques présentées dans ce projet, c'est la dernière qui me parait la plus puissante et la plus efficace.
Tous les fichiers dans geometrie.gz
Pour faire fonctionner tous ces exemples, il faut d'abord s'assurer que la bibliothèque Qt (version développement) est bien installée sur l'ordinateur. On installe ensuite dans le répertoire de l'application main.cpp, tous les autres programmes de type cpp ainsi que le ou les fichiers d'entêtes. La bibliothèque comportant tous les objets géométriques sera mis dans le sous-répertoire geo2D ; un lien symbolique sur geo2D convient (commande linux ls).
En mode "console" on se positionne dans le sous-répertoire contenant l'application et on tape qmake -project -norecursive.
L'option norecursive permettra d'obtenir des programmes plus petits car seules les classes de geo2D réellement utilisées seront pris en charge dans l'application. Cette commande crée le fichier mon_programme.pro où mon_programme est le nom du répertoire courant.
Ensuite on tape qmake. Le fichier Makefile apparaît alors.
On temine enfin en tapant make. Un exécutif portant le nom du répertoire (mon_programme dans l'exemple précédent) est alors créé. Dans les phases de mise au point le lancement de la commande make ne relance la compilation que des programmes modifiés, d'où un gain de temps. Par contre, toujours dans les phases de mise au point, si on ajoute un objet géométrique dans l'application il faudra penser à relancer la commande qmake -project -norecursive puis qmake car les fichiers .pro et Makefile doivent être modifiés.
À la fin on peut utiliser la commande ef (script présent dans geometrie.gz) pour effacer tous les fichiers temporaires.
Structure générale d'une application de géométire dynamique.
Pour faire fonctionner ces exemples il faut s''assurer que les bibliothèques GTK+, GDK et cairo sont bien installées. Les objets géométriques sont placés dans le sous-répertoire geo2D.
On compile les programmes grâce à la commande : g++ `pkg-config --libs --cflags gtk+-2.0` -o mon_programme geo2D/*.cpp mon_programme.cpp.
Les classes et leur hierarchie :
repere
objet_repere
arc_cercle
cercle
courbe
curseur
demi_droite
droite
pt
point
point_libre
point_sur_droite
point_sur_cercle
segment
vecteur
triangle
fonction
class repere {
public:
int X0, Y0;
int XMAX, YMAX;
double unitex, unitey;
double nunitex, nunitey;
repere (int X0, int Y0, int XMAX, int YMAX, double unite, double nunite);
repere (int X0, int Y0, int XMAX, int YMAX, double unitex, double unitey, double nunitex, double nunitey);
void trace (QPainter *painter);
int Iabs (double x);
int Iord (double y);
double abs (int X);
double ord (int Y);
bool affiche (int X, int Y);
};
La classe repère fixe l'emplacement de l'origine sur l'écran, l'échelle utilisée sur les deux axes et indique aux différents objets les dimensions de la fenêtre d'affichage.
Le repère n'est pas nécessairement orthonormal. Si l'unité est différente sur les deux axes les cercles seront représentés par des ellipses ! Le mode orthonormal devra être utilisé pour les constructions géométriques, seuls les courbes de fonctions peuvent nécessiter l'utilisation de repères simplement orthogonaux.
int X0, Y0;
Coordonnées de l'origine du repère dans la fenêtre graphique.
int XMAX, YMAX;
Largeur et hauteur de la fenêtre graphique.
double unitex, unitey;
Valeur en "pixels" des unités sur les axes des abscisses et des ordonnées.
unitex = unitey pour un repère orthonormal.
Pour afficher des points de cooronnées 100 ou 1000, on peut donner à unitex et unitey des valeurs inférieures à 1. Par exemple si unitex = 0.01 le point de coordonnées (0, 500) sera situé 5 pixels plus haut que l'origine.
double nunitex, nunitey;
cs nombres indiquent que l'on veut des taquets de repérage toutes les nunite. Exemple si nunite = 10, les taquets seronts mis en place pour les valeurs -20, -10, 0, 10, 20, 30...
repere (int X0, int Y0, int XMAX, int YMAX, double unite, double nunite);
Construction d'un repère orthonormal. X0 et Y0 sont les coordonnées à l'écran de l'origine du repère, XMAX et YMAX sont les dimensions de la fenêtre graphique, unité est la valeur en pixels d'une unité et nunité définit la fréquence des taquets de repérage.
repere (int X0, int Y0, int XMAX, int YMAX, double unitex, double unitey, double nunitex, double nunitey);
Construction d'un repère orthogonal. X0 et Y0 sont les coordonnées à l'écran de l'origine du repère, XMAX et YMAX sont les dimensions de la fenêtre graphique, unitex et unitey sont les valeurs en pixels d'une unité sur l'axe des abscisses et des ordonnées. nunitex et nunitey définissent la fréquence des taquets de repérage.
void trace (QPainter *painter);
Affiche à l'écran les axes de coordonnées du repère et les taquets de repérage. QPainter *painter s'écrit cairo *cr dans l'environnement GTK+/GDK/cairo.
int Iabs (double x);
Convertit l'abscisse d'un point dans le repère en position sur l'écran.
int Iord (double y);
Convertit l'ordonnée d'un point dans le repère en position sur l'écran.
double abs (int X);
Convertit la position sur écran en abscisse relativement au repère courant.
double ord (int Y);
Convertit la position sur écran en ordonnée relativement au repère courant.
bool affiche (int X, int Y);
retourne TRUE si le point de coordonnées (X, Y) est visible sur l'écran.
class objet_repere {
public:
repere *R;
bool defini;
const char *nom;
objet_repere (const char *nom, repere *R);
};
C'est l'objet de base à partir duquel sont définis quasiment tous les autres objets.
repere *R;
Pointeur sur le repère associé.
bool defini;
vaut TRUE si l'objet existe réellement. Cet indicateur est utilisé par exemple dans l'intersection d'une droite et d'un cercle qui peut être vide ou dans les ensembles d'équation ax+by+c=0 qui ne sont des droites que si a et b sont non tous nuls.
const char *nom;
Pointeur sur le nom de l'objet qui sera affiché lors de l'utilisation de la méthode trace.
objet_repere (const char *nom, repere *R);
Constructeur de l'objet
class pt: public objet_repere {
public:
double x, y;
int X, Y;
pt (const char *nom, repere *R);
pt (pt *A, const char *nom, repere *R);
pt (double x, double y, const char *nom, repere *R);
bool zone (int X, int Y);
void trace (QPainter *painter);
void trace_nom (QPainter *painter);
void pt_x_y (double x, double y);
double distance (pt *A);
void majXY ();
};
Définition d'un point de base.
double x, y;
Coordonnées du point dans le repère R.
int X, Y;
Coordonnées du point dans la fenêtre d'affichage.
pt (const char *nom, repere *R);
Construit un point non défini.
pt (pt *A, const char *nom, repere *R);
Construit une copie du point A.
pt (double x, double y, const char *nom, repere *R);
Construit un point de coordonnées (x, y).
bool zone (int X, int Y);
Retourne TRUE si le point de l'écran de coordonnées (X, Y) est proche du point. Cette méthode sera utilisée par les dispositifs de pointage type souris.
void trace (QPainter *painter);
Trace le point courant.
void trace_nom (QPainter *painter);
Trace uniquement le nom du point.
void pt_x_y (double x, double y);
Redéfinit les coordonnées du point.
double distance (pt *A);
retourne la distance du point A au point courant.
void majXY ();
Met à jour les coordonnées du point à l'écran en fonction des coordonnées (x, y) dans le repère R.
class vecteur: public objet_repere {
public:
double x, y;
double Ox, Oy;
vecteur (const char *nom, repere *R);
vecteur (double x, double y, const char *nom, repere *R);
vecteur (pt *A, pt *B, const char *nom, repere *R);
void somme (vecteur *u, vecteur *v);
void produit (vecteur *u, double k);
double norme ();
void fixe_origine (pt *A);
static double angle (vecteur *u, vecteur *v);
static double produit_scalaire (vecteur *u, vecteur *v);
static double det (vecteur *u, vecteur *v);
bool zone (int X, int Y);
void trace (QPainter *painter);
void vecteur_x_y (double x, double y);
void vecteur_pt_pt (pt *A, pt *B);
};
Vecteur du plan
double x, y;
Coordonnées du vecteur
double Ox, Oy;
Coordonnées du point d'application
vecteur (const char *nom, repere *R);
Construit un vecteur non défini
vecteur (double x, double y, const char *nom, repere *R);
Construit un vecteur de coordonnées (x, y), le point d'application est l'origine du repère par défaut.
vecteur (pt *A, pt *B, const char *nom, repere *R);
Construit le vecteur AB, le point d'application est l'origine du repère par défaut.
void somme (vecteur *u, vecteur *v);
Somme des vecteurs u et v. Utilisation : w.somme (u, v) signifie que w reçoit la somme des coordonnées des vecteurs u et v.
void produit (vecteur *u, double k);
Produit d'un vecteur et d'un réel.
double norme ();
Retourne la norme du vecteur courant.
void fixe_origine (pt *A);
Fixe l'origine de la flèche représentative du vecteur
static double angle (vecteur *u, vecteur *v);
Retourne l'angle de deux vecteurs. Exemple d'utilisation : double a = vecteur::angle (u, v);
static double produit_scalaire (vecteur *u, vecteur *v);
Retourne le produit scalaire des vecteurs u et v.
static double det (vecteur *u, vecteur *v);
Retourne le déterminant des vecteurs u et v.
bool zone (int X, int Y);
Retourne TRUE si le point de l'écran de coordonnées (X, Y) est proche du vecteur.
void trace (QPainter *painter);
Trace la flèche représentative du vecteur au point d'application fixé.
void vecteur_x_y (double x, double y);
Redéfinit les coordonnées du vecteur courant.
void vecteur_pt_pt (pt *A, pt *B);
Redéfinit les coordonnées du vecteur courant à partir des points A et B.
class segment: public objet_repere {
public:
double Ax, Ay, Bx, By;
segment (const char *nom, repere *R);
segment (pt *A, pt *B, const char *nom, repere *R);
segment (double xA, double yA, double xB, double yB, const char *nom, repere *R);
double longueur ();
void trace (QPainter *painter);
bool zone (int X, int Y);
void segment_pt_pt (pt *A, pt *B);
void segment_x_y_x_y (double xA, double yA, double xB, double yB);
};
Définit un segment du plan.
double Ax, Ay, Bx, By;
Coordonnées des extrémités du segment.
segment (const char *nom, repere *R);
Construit un segment non défini.
segment (pt *A, pt *B, const char *nom, repere *R);
Construit le segment AB.
segment (double xA, double yA, double xB, double yB, const char *nom, repere *R);
Construit un segment à partir des coordonnées des extrémités.
double longueur ();
Retourne la longueur du segment courant.
void trace (QPainter *painter);
Trace le segment courant.
bool zone (int X, int Y);
Retourne TRUE si le point de l'écran de coordonnées (X, Y) est proche du segment.
void segment_pt_pt (pt *A, pt *B);
Redéfinit le segment à partir des points A et B.
void segment_x_y_x_y (double xA, double yA, double xB, double yB);
Redéfinit le segment à partir des coordonnées des extrémités.
class droite: public objet_repere {
public:
double a, b, c;
droite (const char *nom, repere *R);
droite (pt *A, pt *B, const char *nom, repere *R);
droite (double a, double b, double c, const char *nom, repere *R);
droite (pt *A, vecteur *u, const char *nom, repere *R);
droite (double xA, double yA, double xB, double yB, const char *nom, repere *R);
void parallele (droite *d, pt *A);
void parallele (segment *s, pt *A);
void perpendiculaire (droite *d, pt *A);
void perpendiculaire (segment *s, pt *A);
void mediatrice (pt *A, pt *B);
void mediatrice (segment *s);
void bissectrice (pt *A, pt *B, pt *C);
double distance (pt *A);
bool zone (int X, int Y);
void trace (QPainter *painter);
void droite_pt_pt (pt *A, pt *B);
void droite_x_y_x_y (double xA, double yA, double xB, double yB);
void droite_a_b_c (double a, double b, double c);
void droite_pt_v (pt *A, vecteur *u);
};
Définit un droite par un équation cartésienne ax+by+c=0. L'indicateur defini de l'objet_repere ne vaut TRUE que si a et b sont non tous nuls.
double a, b, c;
Coefficient d'une équation cartésienne
droite (const char *nom, repere *R);
Construit une droite non définie
droite (pt *A, pt *B, const char *nom, repere *R);
Construit la droite (AB). L'indicateur defini ne vaut TRUE que si la les points A et B sont définis et ont des coordonnées distinctes.
droite (double a, double b, double c, const char *nom, repere *R);
Construit la droite en fixant trois coefficients. a, b doivent être non tous nul.
droite (pt *A, vecteur *u, const char *nom, repere *R);
Construit une droite à partir d'un point et d'un vecteur directeur u. u doit être non nul.
droite (double xA, double yA, double xB, double yB, const char *nom, repere *R);
Construit une droite par les coordonnées de deux points.
void parallele (droite *d, pt *A);
La droite courante devient la parallèle à une droite donnée passant par un point donné.
void parallele (segment *s, pt *A);
Parallèle à un segment.
void perpendiculaire (droite *d, pt *A);
La droite courante devient la perpendiculaire à une droite donnée passant par un point donné.
void perpendiculaire (segment *s, pt *A);
Perpendiculaire à un segment
void mediatrice (pt *A, pt *B);
La droite courante devient la médiatrice de [AB]. A et B doivent être distinct.
void mediatrice (segment *s);
Médiatrice d'un segment
void bissectrice (pt *A, pt *B, pt *C);
Bissectrice de l'angle ABC. A et B d'une part, B et C d'autre part doivent être distincts.
double distance (pt *A);
Retourne la distance de la droite à un point A ou -1 si la droite ou le point n'est pas défini..
bool zone (int X, int Y);
Retourne TRUE si le point de l'écran de coordonnées (X, Y) est proche de la droite.
void trace (QPainter *painter);
Trace la droite courante
void droite_pt_pt (pt *A, pt *B);
Redéfinit la droite à partir des points A et B.
void droite_x_y_x_y (double xA, double yA, double xB, double yB);
Redéfinit la droite à partir des coordonnées de deux points distincts.
void droite_a_b_c (double a, double b, double c);
Redéfinit une droite à partir des coefficients d'un équation cartésienne
void droite_pt_v (pt *A, vecteur *u);
Redéfinit une droite à partir d'un point et d'un vecteur
class cercle: public objet_repere {
public:
double Ox, Oy, r;
cercle (const char *nom, repere *R);
cercle (pt *O, double r, const char *nom, repere *R);
cercle (pt *O, pt *A, const char *nom, repere *R);
cercle (pt *A, pt *B, pt *C, const char *nom, repere *R);
bool zone (int X, int Y);
void trace (QPainter *painter);
void cercle_pt_r (pt *O, double r);
void cercle_x_y_r (double Ox, double Oy, double r);
void cercle_pt_pt (pt *O, pt *A);
void cercle_pt_pt_pt (pt *A, pt *B, pt *C);
};
Définit un cercle par les coordonnées de son centre et son rayon r positif.
double Ox, Oy, r;
Coordonnées du centre et rayon du cercle.
cercle (const char *nom, repere *R);
Construit un cercle non défini
cercle (pt *O, double r, const char *nom, repere *R);
Construit un cercle de centre O et de rayon r.
cercle (pt *O, pt *A, const char *nom, repere *R);
Construit un cercle de centre O passant par A.
cercle (pt *A, pt *B, pt *C, const char *nom, repere *R);
Construit un cercle passant par les points A, B et C. A, B, C ne doivent pas être alignés.
bool zone (int X, int Y);
Retourne TRUE si le point de l'écran de coordonnées (X, Y) est proche du cercle.
void trace (QPainter *painter);
Trace le cercle.
void cercle_pt_r (pt *O, double r);
Redéfinit le cercle à partir du centre O et du rayon r.
void cercle_x_y_r (double Ox, double Oy, double r);
Redéfinit le cercle à partir des coordonnées du centre et du rayon r.
void cercle_pt_pt (pt *O, pt *A);
Redéfinit le cercle à partir du centre et d'un point appartenant à ce cercle.
void cercle_pt_pt_pt (pt *A, pt *B, pt *C);
Redéfinit le cercle à partir de trois points.
class arc_cercle: public objet_repere {
public:
double Ox, Oy, r;
double a, b;
bool sens_trigo;
arc_cercle (const char *nom, repere *R);
arc_cercle (pt *O, double r, double a, double b, const char *nom, repere *R);
arc_cercle (double Ox, double Oy, double r, double a, double b, const char *nom, repere *R);
arc_cercle (pt *O, pt *A, double a, double b, const char *nom, repere *R);
arc_cercle (pt *A, pt *O, pt *B, const char *nom, repere *R);
bool zone (int X, int Y);
void trace (QPainter *painter);
void arc_cercle_pt_r (pt *O, double r, double a, double b);
void arc_cercle_pt_pt (pt *O, pt *A, double a, double b);
void arc_cercle_x_y_r (double Ox, double Oy, double r, double a, double b);
void arc_cercle_pt_pt_pt (pt *A, pt *O, pt *B);
};
Arc de cercle défini à partir d'un centre, d'un rayon, d'un angle de départ et d'un angle d'arrivée.
double Ox, Oy, r;
Coordonnées deu centre et rayon.
double a, b;
angle de départ et d'un angle d'arrivée en radians.
bool sens_trigo;
Si la valeur est TRUE l'arc de cercle sera tracé de l'angle a à l'angle b dans le sens trigonométrique, sinon il sera tracé par le chemin le plus court (sens trigonométrique ou sens inverse).
arc_cercle (const char *nom, repere *R);
Construit un arc de cercle non défini.
arc_cercle (pt *O, double r, double a, double b, const char *nom, repere *R);
Construit un arc de cercle à partir du centre, du rayon de l'angle de départ et de l'angle d'arrivée.
arc_cercle (double Ox, double Oy, double r, double a, double b, const char *nom, repere *R);
Construit un arc de cercle à partir des coordonnées du centre, du rayon de l'angle de départ et de l'angle d'arrivée.
arc_cercle (pt *O, pt *A, double a, double b, const char *nom, repere *R);
Construit un arc de cercle de centre O, de rayon OA, d'angle de départ a et d'angle d'arrivée b.
arc_cercle (pt *A, pt *O, pt *B, const char *nom, repere *R);
Construit un arc de cercle de centre O, de rayon OA ; l'angle de départ est (u, OA) et d'angle d'arrivée (u, OB), u étant le vecteur de coordonnées (1, 0).
bool zone (int X, int Y);
Retourne TRUE si le point de l'écran de coordonnées (X, Y) est proche de l'arc du cercle.
void trace (QPainter *painter);
Trace l'arc de cercle.
void arc_cercle_pt_r (pt *O, double r, double a, double b);
Redéfinit l'arc de cercle.
void arc_cercle_pt_pt (pt *O, pt *A, double a, double b);
Redéfinit l'arc de cercle.
void arc_cercle_x_y_r (double Ox, double Oy, double r, double a, double b);
Redéfinit l'arc de cercle.
void arc_cercle_pt_pt_pt (pt *A, pt *O, pt *B);
Redéfinit l'arc de cercle.
class point_libre: public pt {
public:
bool deplace;
point_libre (double x, double y, const char *nom, repere *R);
bool select (int X, int Y);
bool bouge (int X, int Y);
void stop ();
};
La classe point_libre héritée de la classe pt permet de gérer les déplacements de points sur l'écran en utilisant un dispositif de pointage, c'est à dire la plupart du temps une souris.
bool deplace;
Vaut TRUE si le point en en cours de déplacement.
point_libre (double x, double y, const char *nom, repere *R);
Construit un point déplaçable.
bool select (int X, int Y);
Met l'indicateur de déplacement à TRUE (deplace = TRUE) si le dispositif de pointage de coordonnées (X, Y) est proche du point. Cette méthode est appelée au moment de l'appui sur le bouton de la souris si celle-ci est proche du point.
bool bouge (int X, int Y);
Déplace le point à la position (X, Y) si son indicateur de déplacement deplace vaut TRUE et retourne la valeur de cet indicateur. Un test sur bouge (int X, int Y) permet de savoir si le point a été déplacé et s'il faut donc recalculer les objets créés à partir de ce point.
void stop ();
Arrête le déplacement du point en mettant la valeur FALSE dans la variable deplace. Cette méthode sera appelée au moment du relachement de la souris (mouse release).
class point: public pt {
public:
point (const char *nom, repere *R);
point (double x, double y, const char *nom, repere *R);
void milieu (point *A, point *B);
void symetrique (point *A, point *C);
void rotation (point *A, point *O, double a);
void homothetique (point *A, point *O, double k);
void intersection (droite *d1, droite *d2);
void projection (pt *A, droite *d);
void symetrique (pt *A, droite *d);
void intersection1 (droite *d, cercle *c);
void intersection2 (droite *d, cercle *c);
void intersection1 (cercle *c1, cercle *c2);
void intersection2 (cercle *c1, cercle *c2);
void centre (cercle *c);
void projection (pt *A, segment *s);
void intersection (segment *s1, segment *s2);
void symetrique (pt *A, segment *s);
double distance (droite *d);
double distance (segment *s);
void translation (pt *A, vecteur *v);
};
Ajoute des méthodes complémentaires aux points du plan.
point (const char *nom, repere *R);
Construit un point non défini.
point (double x, double y, const char *nom, repere *R);
Construit un point de coordonnées (x, y)
void milieu (point *A, point *B);
Redéfinit le point comme milieu du segment [AB].
void symetrique (point *A, point *C);
Symétrique de A par rapport à C.
void rotation (point *A, point *O, double a);
Image de A par la rotation de centre O et d'angle a exprimé en radians.
void homothetique (point *A, point *O, double k);
Redéfinit le point comme image de A par l'homothétie de centre O et de rapport k.
void intersection (droite *d1, droite *d2);
Intersection des droites d1 et d2. L'indicateur defini de la sous-classe objet_repere vaut FALSE si les deux droites sont parallèles.
void projection (pt *A, droite *d);
Projeté de A sur d.
void symetrique (pt *A, droite *d);
Symétrique de A par rapport à d.
void intersection1 (droite *d, cercle *c);
Redéfinit le point comme premier point d'intersection d'une droite et d'un cercle. Ce point peut ne pas existé (defini = FALSE) si la droite est trop loin du cercle.
void intersection2 (droite *d, cercle *c);
Redéfinit le point comme second point d'intersection d'une droite et d'un cercle. Ce point peut ne pas exister (defini = FALSE) si la droite est trop loin du cercle.
void intersection1 (cercle *c1, cercle *c2);
Redéfinit le point comme premier point d'intersection de deux cercles. Ce point peut ne pas exister (defini = FALSE) si les cercles sont trop éloignés.
void intersection2 (cercle *c1, cercle *c2);
Redéfinit le point comme second point d'intersection de deux cercles. Ce point peut ne pas exister (defini = FALSE) si les cercles sont trop éloignés.
void centre (cercle *c);
Redéfinit le point comme centre du cercle c.
void projection (pt *A, segment *s);
Redéfinit le point comme projeté orthogonal de A sur le segment s.
void intersection (segment *s1, segment *s2);
Redéfinit le point comme intersection des segments s1 et s2.
void symetrique (pt *A, segment *s);
Redéfinit le point comme symétrique de A par rapport au segment s.
double distance (droite *d);
Retourne la distance du point à la droite d.
double distance (segment *s);
Retourne la distance du point au segment s.
void translation (pt *A, vecteur *v);
Redéfinit le point comme image de A par la translation de vecteur v.
class point_sur_droite: public point_libre {
public:
point_sur_droite (droite *d, const char *nom, repere *R);
point_sur_droite (double x, double y, droite *d, const char *nom, repere *R);
bool bouge (int X, int Y);
void point_sur_droite_d ();
};
La classe point_sur_droite héritée de la classe point_libre permet de gérer les déplacements de points sur sur une droite en utilisant un dispositif de pointage, c'est à dire la plupart du temps une souris.
point_sur_droite (droite *d, const char *nom, repere *R);
Construit un point sur la droite d.
point_sur_droite (double x, double y, droite *d, const char *nom, repere *R);
Construit un point sur la droite d. Le point sera le projeté du point de coordonnées (x, y).
bool bouge (int X, int Y);
Déplace le point au plus proche de la position (X, Y) si son indicateur de déplacement deplace vaut TRUE et retourne la valeur de cet indicateur. Un test sur bouge (int X, int Y) permet de savoir si le point a été déplacé et s'il faut donc recalculer les objets créés à partir de ce point.
void point_sur_droite_d ();
Redéfini la position du point en cas de déplacement de la droite elle-même
class point_sur_cercle: public point_libre {
public:
point_sur_cercle (cercle *c, const char *nom, repere *R);
point_sur_cercle (double a, cercle *c, const char *nom, repere *R);
bool bouge (int X, int Y);
void point_sur_cercle_c ();
};
La classe point_sur_cercle héritée de la classe point_libre permet de gérer les déplacements de points sur sur un cercle en utilisant un dispositif de pointage, c'est à dire la plupart du temps une souris.
point_sur_cercle (cercle *c, const char *nom, repere *R);
Construit un point sur le cercle c.
point_sur_cercle (double a, cercle *c, const char *nom, repere *R);
Construit un point sur le cercle c, a est la valeur en radians de l'angle permettant le placement de ce point.
bool bouge (int X, int Y);
Déplace le point au plus proche de la position (X, Y) si son indicateur de déplacement deplace vaut TRUE et retourne la valeur de cet indicateur. Un test sur bouge (int X, int Y) permet de savoir si le point a été déplacé et s'il faut donc recalculer les objets créés à partir de ce point.
void point_sur_cercle_c ();
Redéfinit la position du point en cas de déplacement du cercle lui-même.
class demi_droite: public objet_repere {
public:
double Ax, Ay;
double Bx, By;
demi_droite (pt *A, pt *B, const char *nom, repere *R);
demi_droite (double Ax, double Ay, double Bx, double By, const char *nom, repere *R);
demi_droite (pt *A, vecteur *u, const char *nom, repere *R);
bool zone (int X, int Y);
void trace (QPainter *painter);
void demi_droite_pt_pt (pt *A, pt *B);
void demi_droite_x_y_x_y (double Ax, double Ay, double Bx, double By);
void demi_droite_pt_v (pt *A, vecteur *u);
};
Demi-droite [AB) d'origine A et passant par B.
double Ax, Ay;
Coordonnéee de A.
double Bx, By;
Coordonnées de B.
demi_droite (pt *A, pt *B, const char *nom, repere *R);
Construit la demi-droite [AB).
demi_droite (double Ax, double Ay, double Bx, double By, const char *nom, repere *R);
Construit la demi-droite [AB) à partir des coordonnées de A et de B.
demi_droite (pt *A, vecteur *u, const char *nom, repere *R);
Construit la demi-droite d'origine A et de direction u.
bool zone (int X, int Y);
Retourne TRUE si le point de l'écran de coordonnées (X, Y) est proche de la demi-droite.
void trace (QPainter *painter);
Trace la demi-droite.
void demi_droite_pt_pt (pt *A, pt *B);
Redéfinit la demi-droite.
void demi_droite_x_y_x_y (double Ax, double Ay, double Bx, double By);
Redéfinit la demi-droite.
void demi_droite_pt_v (pt *A, vecteur *u);
Redéfinit la demi-droite.
class triangle: public objet_repere {
public:
pt *A;
pt *B;
pt *C;
triangle (pt *A, pt *B, pt *C, const char *nom, repere *R);
bool zone (int X, int Y);
void trace (QPainter *painter);
};
Triangle ABC.
pt *A, *B, *C;
Pointeurs sur les trois points du triangle
triangle (pt *A, pt *B, pt *C, const char *nom, repere *R);
Construit le triangle ABC.
bool zone (int X, int Y);
Retourne TRUE si le point de l'écran de coordonnées (X, Y) est proche du triangle.
void trace (QPainter *painter);
Trace le triangle.
class curseur: public objet_repere {
public:
int X, Y, W;
bool deplace;
bool deplace_curseur;
double min, max, val;
curseur (double min, double max, double val, int X, int Y, int W, const char *nom, repere *R);
bool zone (int X, int Y);
bool bouge (int X, int Y);
bool select (int X, int Y);
void stop ();
bool zone_curseur (int X, int Y);
bool bouge_curseur (int X, int Y);
bool select_curseur (int X, int Y);
void stop_curseur ();
void trace (QPainter *painter);
double valeur ();
void curseur_d (double min, double max, double val, int X, int Y, int W);
};
Il s'agit d'un curseur (ou Slider en anglais). Ce curseur est muni d'un bouton permettant de faire varier la valeur retournée et d'un point d'ancrage qui permet le déplacement du curseur lui-même.
int X, Y, W;
Coordonnées du curseur et largeur de la barre de défilement.
bool deplace;
Vaut TRUE si le bouton du curseur est en cours de déplacement.
bool deplace_curseur;
Vaut TRUE si le curseur est en cours de déplacement.
double min, max, val;
min et max sont les valeurs minimale et maximale que peut retourner le curseur. val est la valeur courante.
curseur (double min, double max, double val, int X, int Y, int W, const char *nom, repere *R);
Construit un curseur.
bool zone (int X, int Y);
vaut TRUE si le point de coordonnées (X, Y) est proche du bouton du curseur.
bool bouge (int X, int Y);
Déplace le bouton du curseur au plus proche de la position (X, Y) si son indicateur de déplacement deplace vaut TRUE et retourne la valeur de cet indicateur. Un test sur bouge (int X, int Y) permet de savoir si le bouton du curseur a été déplacé et s'il faut donc recalculer les objets créés à partir de la valeur retournée par le curseur.
bool select (int X, int Y);
Met l'indicateur de déplacement à TRUE (deplace = TRUE) si le dispositif de pointage de coordonnées (X, Y) est proche du bouton du curseur. Cette méthode est appelée au moment de l'appui sur le bouton de la souris si celle-ci est proche du bouton du curseur.
void stop ();
Arrête le déplacement du point en mettant la valeur FALSE dans la variable deplace. Cette méthode sera appelée au moment du relachement de la souris.
bool zone_curseur (int X, int Y);
vaut TRUE si le point de coordonnées (X, Y) est proche du curseur.
bool bouge_curseur (int X, int Y);
Déplace le curseur au plus proche de la position (X, Y) si son indicateur de déplacement deplace_curseur vaut TRUE et retourne la valeur de cet indicateur.
bool select_curseur (int X, int Y);
Met l'indicateur de déplacement à TRUE (deplace_curseur = TRUE) si le dispositif de pointage de coordonnées (X, Y) est proche du curseur. Cette méthode est appelée au moment de l'appui sur le bouton de la souris si celle-ci est proche du curseur.
void stop_curseur ();
Arrête le déplacement du point en mettant la valeur FALSE dans la variable deplace_curseur.
void trace (QPainter *painter);
Dessine le curseur.
double valeur ();
Retourne la valeur courante du curseur.
void curseur_d (double min, double max, double val, int X, int Y, int W);
Redéfinit le curseur.
class fonction {
public:
virtual bool def (double x);
virtual double image (double x);
};
Fonction numérique de la variable réelle : on devra définir fonction::def et fonction::image si on veut utiliser la classe courbe. Dans le cas d'une utilisation de plusieurs fonctions ou d'une fonction dépendant d'un paramètre on devra créer des classes dérivées de la classe fonction (cf fonct.html, fparm.html et tgte_derivee.html). C'est dans ce but que def et image sont déclarés virtual.
Des pointeurs sur des fonctions comme dans la version cairo_c de cette bibliothèque auraient pu être utilisés (cf courbe_f.c et fparm.c).
virtual bool def (double x);
Retourne TRUE si x appartient à l'ensemble de définition de la fonction.
virtual double image (double x);
Retourne l'image du réel x par la fonction.
class courbe: public objet_repere {
public:
fonction *f;
courbe (fonction *f, const char *nom, repere *R);
bool zone (int X, int Y);
void trace (QPainter *painter);
};
Trace la courbe d'une fonction numérique de la variable réelle.
fonction *f;
Pointeur sur la fonction.
courbe (fonction *f, const char *nom, repere *R);
Construit la courbe de la fonction f.
bool zone (int X, int Y);
vaut TRUE si le point de coordonnées (X, Y) est proche de la courbe.
void trace (QPainter *painter);
Trace la courbe de f.