Je propose ici une bibliothèque d'objets géométriques et des exemples. Il faut s'assurer que les objets géométriques sont bien dans un sous-répertoire du répertoire contenant les exemples. Tous les programmes sont en C et peuvent être compilés en tapant une commande du type :
gcc `pkg-config --libs --cflags gtk+-2.0` -o mon_programme geo2D/*.c mon_programme.c
Il faut bien sûr s'assurer que les bibliothèques GTK+, GDK, cairo, version développement, sont installées.
Fichier : geo2D/geo2D.h
#ifndef GEO2D_H
#define GEO2D_H
#include <stdlib.h>
#include <gdk/gdk.h>
#include <gtk/gtk.h>
#include <cairo.h>
#include <math.h>
/* repere */
typedef struct {
int X0, Y0;
int XMAX, YMAX;
double unitex, unitey;
double nunitex, nunitey;
} repere;
repere *repere_def (int X0, int Y0, int XMAX, int YMAX, double unitex, double unitey, double nunitex, double nunitey);
void repere_trace (repere *R, cairo_t *cr);
int repere_Iabs (repere *R, double x);
int repere_Iord (repere *R, double y);
double repere_abs (repere *R, int X);
double repere_ord (repere *R, int Y);
int repere_affiche (repere *R, int X, int Y);
void repere_maj (repere *R, int X0, int Y0, int XMAX, int YMAX, double unitex, double unitey, double nunitex, double nunitey);
/* objet_repere */
typedef struct {
const char *nom;
repere *R;
int defini;
} objet_repere;
objet_repere *objet_repere_def (const char *nom, repere *R);
/* droite */
typedef struct {
objet_repere *or;
double a, b, c;
} droite;
/* cercle */
typedef struct {
objet_repere *or;
double Ox, Oy, r;
} cercle;
/* pt */
typedef struct {
objet_repere *or;
double x, y;
int X, Y;
int deplace; // utilisé uniquement pour les points libres, les points sur droite et sur cercle
droite *d; // utilisé uniquement pour les points sur droite
cercle *c; // utilisé uniquement pour les points sur cercle
double a; // utilisé uniquement pour les points sur cercle
} pt;
pt *pt_def (double x, double y, const char *nom, repere *R);
int pt_zone (pt *P, int X, int Y);
void pt_trace (pt *P, cairo_t *cr);
void pt_trace_nom (pt *P, cairo_t *cr);
void pt_x_y (pt *P, double x, double y);
double pt_distance (pt *P, pt *A);
void pt_majXY (pt *P);
/* vecteur */
typedef struct {
objet_repere *or;
double x, y;
double Ox, Oy;
} vecteur;
vecteur *vecteur_def (double x, double y, const char *nom, repere *R);
vecteur *somme (vecteur *u, vecteur *v);
vecteur *produit (vecteur *u, double k);
double norme (vecteur *u);
void fixe_origine (vecteur *u, double Ox, double Oy);
double angle (vecteur *u, vecteur *v);
double produit_scalaire (vecteur *u, vecteur *v);
double det (vecteur *u, vecteur *v);
int vecteur_zone (vecteur *u, int X, int Y);
void vecteur_trace (vecteur *u, cairo_t *cr);
void vecteur_x_y (vecteur *u, double x, double y);
void vecteur_pt_pt (vecteur *u, pt *A, pt *B);
double norme2 (vecteur *u);
/* segment */
typedef struct {
objet_repere *or;
double Ax, Ay, Bx, By;
int AX, AY, BX, BY;
} segment;
segment *segment_def (double xA, double yA, double xB, double yB, const char *nom, repere *R);
double segment_longueur (segment *s);
void segment_trace (segment *s, cairo_t *cr);
int segment_zone (segment *s, int X, int Y);
void segment_pt_pt (segment *s, pt *A, pt *B);
void segment_x_y_x_y (segment *s, double xA, double yA, double xB, double yB);
void segment_majXY (segment *s);
void segment_X_Y_X_Y (segment *s, int XA, int YA, int XB, int YB);
/* droite */
droite *droite_def (double a, double b, double c, const char *nom, repere *R);
void parallele (droite *d, droite *d1, pt *A);
void perpendiculaire (droite *d, droite *d1, pt *A);
void mediatrice (droite *d, pt *A, pt *B);
void bissectrice (droite *d, pt *A, pt *B, pt *C);
double droite_distance (droite *d, pt *A);
int droite_zone (droite *d, int X, int Y);
void droite_trace (droite *d, cairo_t *cr);
void droite_pt_pt (droite *d, pt *A, pt *B);
void droite_x_y_x_y (droite *d, double xA, double yA, double xB, double yB);
void droite_a_b_c (droite *d, double a, double b, double c);
void droite_pt_v (droite *d, pt *A, vecteur *u);
/* cercle */
cercle *cercle_def (double Ox, double Oy, double r, const char *nom, repere *R);
int cercle_zone (cercle *c, int X, int Y);
void cercle_trace (cercle *c, cairo_t *cr);
void cercle_pt_r (cercle *c, pt *O, double r);
void cercle_x_y_r (cercle *c, double Ox, double Oy, double r);
void cercle_pt_pt (cercle *c, pt *O, pt *A);
void cercle_pt_pt_pt (cercle *c, pt *A, pt *B, pt *C);
/* arc_cercle */
typedef struct {
objet_repere *or;
double Ox, Oy, r;
double a, b;
int sens_trigo;
} arc_cercle;
arc_cercle *arc_cercle_def (double Ox, double Oy, double r,
double a, double b, const char *nom, repere *R);
int arc_cercle_zone (arc_cercle *ac, int X, int Y);
void arc_cercle_trace (arc_cercle *ac, cairo_t *cr);
void arc_cercle_pt_r (arc_cercle *ac, pt *O, double r, double a, double b);
void arc_cercle_pt_pt (arc_cercle *ac, pt *O, pt *A, double a, double b);
void arc_cercle_x_y_r (arc_cercle *ac, double Ox, double Oy, double r, double a, double b);
void arc_cercle_pt_pt_pt (arc_cercle *ac, pt *A, pt *O, pt *B);
double ac_na (double a);
double ac_angle (double vx, double vy);
/* point_libre */
pt *point_libre_def (double x, double y, const char *nom, repere *R);
int pt_select (pt *M, int X, int Y);
int point_libre_bouge (pt *M, int X, int Y);
void pt_stop (pt *M);
/* point */
pt *point_def (double x, double y, const char *nom, repere *R);
void point_intersection_d_c (pt *P, droite *d, cercle *c, double signe);
void point_intersection_c_c (pt *P, cercle *c1, cercle *c2, double signe);
void point_milieu (pt *P, pt *A, pt *B);
void point_symetrique_pt (pt *P, pt *A, pt *C);
void point_rotation (pt *P, pt *A, pt *O, double a);
void point_homothetique (pt *P, pt *A, pt *O, double k);
void point_intersection_d_d (pt *P, droite *d1, droite *d2);
void point_projection (pt *P, pt *A, droite *d);
void point_symetrique_d (pt *P, pt *A, droite *d);
void point_centre (pt *P, cercle *c);
double point_distance (pt *P, droite *d);
void point_translation (pt *P, pt *A, vecteur *v);
/* point_sur_droite */
pt *point_sur_droite_def (double x, double y, droite *d, const char *nom, repere *R);
int point_sur_droite_bouge (pt *P, int X, int Y);
void point_sur_droite_d (pt *P);
/* point_sur_cercle */
double point_sur_cercle_maj_a (int X, int Y, cercle *c);
pt *point_sur_cercle_def (double a, cercle *c, const char *nom, repere *R);
int point_sur_cercle_bouge (pt *P, int X, int Y);
void point_sur_cercle_c (pt *P);
/* demi_droite */
typedef struct {
objet_repere *or;
double Ax, Ay;
double Bx, By;
} demi_droite;
demi_droite *demi_droite_def (double Ax, double Ay, double Bx, double By,
const char *nom, repere *R);
int demi_droite_zone (demi_droite *d, int X, int Y);
void demi_droite_trace (demi_droite *d, cairo_t *cr);
void demi_droite_pt_pt (demi_droite *d, pt *A, pt *B);
void demi_droite_x_y_x_y (demi_droite *d, double Ax, double Ay, double Bx, double By);
void demi_droite_pt_v (demi_droite *d, pt *A, vecteur *u);
/* triangle */
typedef struct {
objet_repere *or;
pt *A, *B, *C;
} triangle;
triangle *triangle_def (pt *A, pt *B, pt *C, const char *nom, repere *R);
int zone_pt_pt (int X, int Y, pt *A, pt *B);
int triangle_zone (triangle *t, int X, int Y);
void triangle_trace (triangle *t, cairo_t *cr);
/* curseur */
typedef struct {
objet_repere *or;
int X, Y, W;
int deplace;
int deplace_curseur;
double min, max, val;
} curseur;
curseur *curseur_def (double min, double max, double val,
int X, int Y, int W,
const char *nom, repere *R);
int val_curseur_zone (curseur *c, int X, int Y);
int val_curseur_select (curseur *c, int X, int Y);
int val_curseur_bouge (curseur *c, int X, int Y);
void val_curseur_stop (curseur *c);
int curseur_zone (curseur *c, int X, int Y);
int curseur_select (curseur *c, int X, int Y);
int curseur_bouge (curseur *c, int X, int Y);
void curseur_stop (curseur *c);
void curseur_trace (curseur *c, cairo_t *cr);
double curseur_val (curseur *c);
void curseur_d (curseur *c, double min, double max, double val, int X, int Y, int W);
/* fonction */
typedef struct {
int (*def) (double x); // pointeurs vers une fonction
double (*image) (double x); // qu'il faudra définir. cf courbe_f.c et fparm.c
} fonction;
/* courbe */
typedef struct {
objet_repere *or;
fonction *f;
} courbe;
courbe *courbe_def (fonction *f, const char *nom, repere *R);
int courbe_zone (courbe *c, int X, int Y);
void courbe_trace (courbe *c, cairo_t *cr);
#endif