Autodoc

Voici la documentation inclue dans le code source du programme, extraite grâce au module autodoc de Sphinx.

wxgeo

Regroupe la majorité des outils utiles à un professeur de mathématiques.

wxgeo.API

class wxgeometrie.API.canvas.Canvas(couleur_fond='w', dimensions=None, feuille=None)

Partie du canvas indépendante de la librairie graphique (Wx actuellement).

affichage_gele
affichage_gele_en_apparence
afficher_axes
afficher_fleches
afficher_objets_caches
afficher_quadrillage
angle(**kw)
arc(*args, **kw)
codage(**kw)
codage_angle(**kw)
coder(event)
coo2pix(x, y)

Convertit des coordonnées en pixel.

dcoo2pix(dx, dy)

Convertit un déplacement exprimé en coordonnées en un déplacement en pixels.

decoder(event)
decoration_texte(**kw)
dessiner(objet)
dessiner_arc(*args, **kw)
dessiner_ligne(*args, **kw)
dessiner_point(*args, **kw)
dessiner_polygone(*args, **kw)
dessiner_texte(*args, **kw)
dimensions
dimensions_fenetre
dpix2coo(dpx, dpy)

Convertit un déplacement exprimé en pixels en un déplacement exprimé en coordonnées.

effacer_traces(event)
executer(commande, parser=False)

Exécute une commande dans la feuille.

NB: le parser n’est PAS activé par défaut, par souci de rapidité.

exporter(fichier, format=None, dpi=None, zone=None, echelle=None, taille=None, keep_ratio=False)

Export de la feuille sous forme d’un fichier (png, eps, …).

Paramètres:
  • fichier (string,file) – le fichier lui-même, ou son emplacement.
  • format – le format de l’image (PNG, SVG, …). Inutile si le nom du fichier est donné avec une extension connue.
  • dpi (int,float) – résolution souhaitée (en dot par inch)
  • zone (tuple) – (xmin, xmax, ymin, ymax) : pour n’exporter qu’une partie de la feuille (png seulement).
  • echelle (tuple) – (x, y) : nombre de cm pour une unité en abscisse ; en ordonnée
  • taille (tuple) – (largeur, hauteur) : taille de l’image en cm.
  • keep_ratio (bool) – indique si le ratio doit être préservé en cas de redimensionnement.

Les paramètres echelle et taille ne peuvent être fournis simultanément.

fenetre
feuille_actuelle
fleche(*args, **kw)
fleche_courbe(**kw)
geler_affichage(geler=True, actualiser=False, seulement_en_apparence=False, sablier=False)

À utiliser au sein d’un contexte “with”:
with self.geler_affichage():
# some action

Si actualiser = True, l’affichage est rafraichi au dégel. Si seulement_en_apparence = True, l’affichage n’est pas gelé en interne, mais les modifications ne s’affichent pas à l’écran (le gain de vitesse est alors négligeable, mais esthétiquement ça évite que des modifications successives apparaissent à l’écran).

Si sablier = True, le pointeur de la souris est remplacé temporairement par un sablier.

gerer_parametre_afficher_axes(afficher=None)

Afficher ou non les axes.

gerer_parametre_afficher_objets_caches(afficher=None)

Indique si les objets cachés sont affichés ou non.

gerer_parametre_afficher_quadrillage(afficher=None)

Afficher ou non le(s) quadrillage(s).

gerer_parametre_grille_aimantee(afficher=None)

Indique si les points doivent se placer sur le quadrillage.

gerer_parametre_orthonorme(afficher=None)

Afficher la figure dans un repère toujours orthonormé.

gradu
hauteur
initialiser()
largeur
ligne(*args, **kw)
lignes(*args, **kw)
liste_axes
nettoyer_feuille(event)
orthonorme
orthonormer(event=None, mode=1)

mode 0 : on orthonormalise le repère en restreignant la vue. mode 1 : on orthonormalise le repère en élargissant la vue.

param(key, **kw)
pas()
pix2coo(px, py)

Convertit un pixel en coordonnées.

point(*args, **kw)
polygone(*args, **kw)
quadrillage_defaut(event=None)
quadrillage_demigraduation(event=None)
quadrillage_demigraduation_colore(event=None, couleur=None)
quadrillage_millimetre(event=None)
quadrillage_millimetre_colore(event=None, couleur=None)
quadrillages
rafraichir_affichage(dessin_temporaire=False, rafraichir_axes=None)
ratio
rectangle(**kw)
rectangle_selection(xy0, xy1, coins=False, coin_actif=None)
rectangle_zoom(xy0, xy1)
repere
repere_011(event=None)
repere_OIJ(event=None)
repere_Oij(event=None)
saturation(i)
selection_en_gras()
synchroniser_fenetre()

Détecte la fenêtre d’affichage et l’enregistre. Ce peut être utile si l’on utilise une commande de haut niveau de matplolib, qui calcule automatiquement la meilleure fenêtre d’affichage.

texte(*args, **kw)
txt_box(matplotlib_text)

Retourne l’espace (rectangulaire) occupé par le texte.

Retourne un objet Bbox, possédant des attributs xmin, xmax, ymin, ymax, height et width. (En pixels).

utiliser_repere
xmax
xmin
ymax
ymin
zoom_auto(event=None)
zoom_in(event=None)
zoom_large(event=None)
zoom_ligne
zoom_line(event=None, valeur=100)
zoom_normal(event=None)
zoom_out(event=None)
zoom_text(event=None, valeur=100)
zoom_texte
zoom_videoprojecteur(event=None)
zoom_videoprojecteur_large(event=None)
zoomer(coeff)
class wxgeometrie.API.canvas.GelAffichage(canvas, geler=True, actualiser=False, seulement_en_apparence=False, sablier=False)
wxgeometrie.API.canvas.partial_track(meth)
wxgeometrie.API.canvas.track(meth)

Gère l’import de fichiers de versions antérieures de WxGéométrie.

À terme, on devrait aussi pouvoir importer ou exporter des fichiers Géogébra par exemple.

wxgeometrie.API.filtres.filtre_versions_anterieures(fgeo, version)
class wxgeometrie.API.macros_construction.Macro_construction(nom=None)

Lecteur de macros.

Lit et interprète le fichier de macro de construction.

enregistrer(path)
ouvrir(path)
class wxgeometrie.API.moteur_graphique.AjusterEchelle(moteur_graphique, echelle=None, taille=None, keep_ratio=False)
class wxgeometrie.API.moteur_graphique.Angle(canvas, **kw)
arc_angle(i=0)
set(**kw)
class wxgeometrie.API.moteur_graphique.ArcDeCercle(canvas, **kw)
set(**kw)
taille = 4
vecteur = (1, 0)
x = 0
y = 0
class wxgeometrie.API.moteur_graphique.Codage(canvas, **kw)

Objet graphique servant à coder les segments et arcs de même longueur.

Paramètres: * taille: taille du symbole (en pixels). * angle: angle relatif au segment, en degrés, pour les symboles / et X. * position: position du symbole (couple de coordonnées). * direction: couple (dx, dy) donnant l’orientation du segment.

Ce couple est exprimé en coordonnées (et non en pixels).
  • marge: si la longueur en pixels correspondant à (dx, dy) est inférieure à la marge + la taille du codage, le codage n’est pas affiché.
angle = 60
direction = (1, 0)
marge = 0
position = (0, 0)
set(**kw)
style = '/'
taille = 10
class wxgeometrie.API.moteur_graphique.CodageAngle(canvas, angle_associe, **kw)

Objet graphique servant à coder des angles de même mesure.

L’objet CodageAngle doit être associé à un objet graphique Angle préexistant. Il en partage les propriétés.

class wxgeometrie.API.moteur_graphique.CollecterArtistes(moteur_graphique)
class wxgeometrie.API.moteur_graphique.ConvertisseurBase

Classe générique dont dérivent tous les convertisseurs d’objets matplotlib.

convertir(obj, chiffres_significatifs=None)

Appelle la méthode spécifique à l’objet matplotlib.

class wxgeometrie.API.moteur_graphique.ConvertisseurTikz(fenetre, resolution=1000)

Convertit un objet matplotlib en instruction Tikz.

“cs”: nombre de chiffres significatifs à afficher.

Line2D(l)
LineCollection(lc)
Polygon(p)
Text(t)
class wxgeometrie.API.moteur_graphique.DecorationTexte(canvas, texte_associe=None, **kw)

Encadrement et fond associé à un texte.

En cas de zoom sur le texte, la taille du texte change, et la taille du cadre est alors automatiquement recalculée (ce qui n’est pas le cas pour Polygon ou FancyBboxPatch).

set(**kw)
class wxgeometrie.API.moteur_graphique.Fleche(canvas, **kw)
xy0 = (0, 0)
xy1 = (1, 1)
class wxgeometrie.API.moteur_graphique.FlecheCourbe(canvas, **kw)

Une flêche (éventuellement double) en forme d’arc de cercle.

En plus des styles de matplotlib.collections.LineCollection, les styles suivants sont définis: - taille: la longueur de la pointe (en pixels) ; - double: flêche double ou non ; - position: position (entre 0 et 1) de la pointe sur la flêche.

ex: 1 pour l’extrémité finale, 0.5 pour le milieu, 0 pour le début.
  • angle: l’ouverture de la pointe (en degrés) ;
  • intervalle: angle de début et de fin de l’arc (radians) ;
  • centre: centre du cercle contenant l’arc ;
  • rayon: rayon du cercle contenant l’arc ;
  • sens: orientation de l’arc (1 ou -1).
centre = (0, 0)
intervalle = (0, 3.141592653589793)
rayon = 1
sens = 1
class wxgeometrie.API.moteur_graphique.FlecheGenerique(canvas, **kw)
angle = 60
double = False
position = 1
taille = 10
class wxgeometrie.API.moteur_graphique.LigneDecoree(canvas, **kw)
set(**kw)
set_alpha(alpha)
taille = NotImplemented
class wxgeometrie.API.moteur_graphique.Moteur_graphique(canvas)
ajouter(artiste)

Ajoute un artiste (objet graphique de matplotlib) à dessiner.

NB: “artiste” peut aussi être une liste d’artistes, ou une liste de listes…

ajouter_angle(**kw)
ajouter_arc(x, y, vecteur, color='k', **kw)
ajouter_cercle(xy=(0, 0), r=1, **kw)
ajouter_codage(**kw)
ajouter_codage_angle(**kw)
ajouter_decoration_texte(**kw)
ajouter_fleche(x0=0, y0=0, x1=1, y1=1, **kw)
ajouter_fleche_courbe(**kw)
ajouter_ligne(x=(0, 1), y=(1, 0), color='b', pixel=False, **kw)
ajouter_lignes(segments=(), **kw)
ajouter_point(x, y, plein=True, **kw)
ajouter_polygone(x=(0, 1, 1, 0), y=(1, 0, 0, 1), facecolor='b', pixel=False, **kw)
ajouter_rectangle(xy=(0, 0), w=1, h=1, **kw)
ajouter_texte(x=0, y=0, txt='hello !', pixel=False, **kw)
angle(**kw)
arc(x, y, vecteur, **kw)
cercle(xy=(0, 0), r=1, **kw)
codage(**kw)
codage_angle(**kw)
decoration_texte(**kw)
dessiner(dessin_temporaire=False, rafraichir_axes=False)
exporter(fichier, format=None, dpi=None, zone=None, echelle=None, taille=None, keep_ratio=False)

Exporter la figure.

exporter_tikz(chiffres_significatifs=4)
fleche(xy0=(0, 0), xy1=(1, 1), **kw)
fleche_courbe(**kw)
infos()

Informations utiles pour le débogage.

ligne(x=(0, 1), y=(1, 0), pixel=False, **kw)
lignes(segments=(), **kw)
point(x, y, plein=True, **kw)

Un petit cercle, vide ou plein.

polygone(x=(0, 1, 1, 0), y=(1, 0, 0, 1), pixel=False, **kw)
rectangle(xy=(0, 0), w=1, h=1, **kw)
restaurer_dessin()

Restaure le dernier dessin.

texte(x=0, y=0, txt='hello !', pixel=False, **kw)
zoom_ligne
zoom_texte
class wxgeometrie.API.moteur_graphique.ZoomArtistes(axes, zoom_texte, zoom_ligne)
wxgeometrie.API.parametres.actualiser_module(module, fichier)

Rafraichit le contenu d’un module à partir d’un fichier XML.

wxgeometrie.API.parametres.sauvegarder_module(module, nom='main')

Renvoie le contenu d’un module sous forme d’un fichier XML.

Au lieu du module lui-même, “module” peut être un dictionnaire correspondant au dictionnaire du module (éventuellement modifié).

class wxgeometrie.API.sauvegarde.FichierGEO(texte='', encoding='utf-8', **args)

Classe utilisée pour manipuler un fichier .geo.

On peut aussi utiliser le DOM XML, mais les spécifications du format de fichier .geo sont plus restreintes, et cette classe offre une surcouche au DOM XML pour un accès plus simple.

ajouter(nom, racine=None, contenu=None)

Ajoute une ou plusieurs nouvelle(s) node(s) nommée(s) “nom” à “racine”, leur contenu étant donné par “contenu”. Renvoie le contenu, ou la nouvelle racine crée (si le contenu était vide).

data
defaut = {'module': '', 'nom': '', 'repertoire': '', 'type': 'Fichier WxGeometrie', 'version': '18.08.1'}
ecrire(path, compressed=False)

Ecrit dans un fichier dont l’adresse est donnée par “path”.

L’encodage est fixé par “self.encoding”. Eventuellement, le contenu peut-être compressé au format zip.

exporter()
importer(texte)
module
nom
ouvrir(path, compressed=None)

Retourne un objet FichierGEO à partir du fichier dont l’adresse est donnée par “path”.

Si l’attribut “zip” n’est pas fixé, la détection est automatique.

repertoire
type
version
version_interne(version=None)

Renvoie le numéro de version sous forme d’une liste, ex: [12, 4, 1] pour la version 12.4.1.

Par défaut, le numéro de version est celui du logiciel ayant servi à créer le fichier.

class wxgeometrie.API.sauvegarde.FichierSession(*fichiers, **infos)
ajouter(*fichiers)
ecrire(path, compresser=True)
ouvrir(path)
wxgeometrie.API.sauvegarde.ouvrir_fichierGEO(path)

Alias de “FichierGEO().ouvrir(path)”.

wxgeo.geolib

class wxgeometrie.geolib.angles.Angle(point1=None, point2=None, point3=None, **styles)

Un angle.

Un angle non orienté, défini par 3 points A, B, C -> angle /ABC.

image_par(transformation)
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

sens
class wxgeometrie.geolib.angles.Angle_generique(**styles)

Un angle générique (en radian).

Classe mère des angles orientés ou non.

deg
degre
grad
info
mesure
rad
radian
class wxgeometrie.geolib.angles.Angle_libre(variable=None, unite=None, **styles)

Un angle libre.

Un angle défini par sa valeur numérique (en radian).

variable

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.angles.Angle_oriente(point1=None, point2=None, point3=None, **styles)

Un angle orienté.

Un angle orienté défini par 3 points A, B, C -> angle (BA>, BC>).

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.angles.Angle_vectoriel(vecteur1=None, vecteur2=None, **styles)

Un angle défini par des vecteurs.

Un angle orienté défini par deux vecteurs (non affiché).

vecteur1

Un descripteur pour un argument d’un objet.

vecteur2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.angles.Secteur_angulaire(point=None, vecteur1=None, vecteur2=None, **styles)

Classe mère de tous les angles “affichables”.

image_par(transformation)
point

Un descripteur pour un argument d’un objet.

sens
vecteur1

Un descripteur pour un argument d’un objet.

vecteur2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.cercles.Arc_cercle(centre=None, point1=None, point2=None, **styles)

Un arc de cercle.

Un arc de cercle orienté, défini par son centre et ses extremités(*), dans le sens direct.

(*) note : le troisième point n’appartient pas forcément à l’arc de cercle, mais sert à en délimiter l’angle au centre.

centre

Un descripteur pour un argument d’un objet.

extremites
image_par(transformation)
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.cercles.Arc_generique(centre, point, **styles)

La classe mère de tous les arcs de cercles.

centre

Un descripteur pour un argument d’un objet.

equation_formatee

Equation sous forme lisible par l’utilisateur.

extremites

Extrémités de l’arc.

info
longueur
point

Un descripteur pour un argument d’un objet.

rayon
class wxgeometrie.geolib.cercles.Arc_oriente(point1=None, point2=None, point3=None, **styles)

Un arc de cercle orienté.

Un arc de cercle orienté, défini par ses extrémités, et un autre point.

image_par(transformation)
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

sens
class wxgeometrie.geolib.cercles.Arc_points(point1=None, point2=None, point3=None, **styles)

Un arc défini par 3 points.

Un arc de cercle, défini par ses extrémités, et un autre point.

extremites
image_par(transformation)
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.cercles.Cercle(centre=None, point=None, **styles)

Un cercle.

Un cercle défini par son centre et un point du cercle.

centre

Un descripteur pour un argument d’un objet.

image_par(transformation)
point

Un descripteur pour un argument d’un objet.

rayon
class wxgeometrie.geolib.cercles.Cercle_Arc_generique(centre, **styles)

La classe mère de tous les cercles et arcs de cercles.

centre

Un descripteur pour un argument d’un objet.

diametre
rayon
class wxgeometrie.geolib.cercles.Cercle_diametre(point1=None, point2=None, **styles)

Un cercle défini par un diamètre.

Un cercle défini par un diamètre [AB].

image_par(transformation)
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

rayon
class wxgeometrie.geolib.cercles.Cercle_equation(a=0, b=0, c=-1, **styles)

Un cercle défini par une équation.

Un cercle d’équation donnée sous forme d’un triplet (a, b, c). (x**2 + y**2 + ax + by + c = 0)

a

Un descripteur pour un argument d’un objet.

b

Un descripteur pour un argument d’un objet.

c

Un descripteur pour un argument d’un objet.

image_par(transformation)
rayon
class wxgeometrie.geolib.cercles.Cercle_generique(centre, **styles)

Un cercle générique.

Usage interne : la classe mère pour tous les types de cercles.

centre

Un descripteur pour un argument d’un objet.

equation_formatee

Equation sous forme lisible par l’utilisateur.

info
perimetre
class wxgeometrie.geolib.cercles.Cercle_points(point1=None, point2=None, point3=None, **styles)

Un cercle défini par 3 points.

Un cercle défini par la donnée de 3 points du cercle.

image_par(transformation)
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

rayon
class wxgeometrie.geolib.cercles.Cercle_rayon(centre=None, rayon=None, **styles)

Un cercle de rayon fixé.

Un cercle défini par son centre et son rayon.

centre

Un descripteur pour un argument d’un objet.

image_par(transformation)
rayon

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.cercles.Demicercle(point1=None, point2=None, **styles)

Un demi-cercle.

Un demi-cercle orienté, défini par ses extrémités, dans le sens direct.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.cercles.Disque(cercle=None, **styles)

Un disque.

Un disque défini par le cercle le délimitant.

aire
cercle

Un descripteur pour un argument d’un objet.

equation_formatee

Equation sous forme lisible par l’utilisateur.

image_par(transformation)
info
rayon
class wxgeometrie.geolib.contexte.Contexte(parent=None, **kw)

Gestionnaire de contexte.

Exemple d’usage: >>> from wxgeometrie.geolib.contexte import Contexte >>> # Contexte global >>> contexte = Contexte(exact = False, decimales = 7) >>> # Contexte local >>> with contexte(exact = True): … print contexte[“exact”] True >>> print contexte[“exact”] False

get(key, default=None)
new()

Crée un nouveau contexte-fils, qui hérite de celui-ci.

Toutes les clés non trouvées du contexte-fils sont ensuite cherchées dans le contexte père.

class wxgeometrie.geolib.courbes.Courbe(fonction, **styles)

Une courbe de fonction.

L’expression doit être donnée en fonction de “x”. Exemple : “2x^2-1/x+1”

fonction

Un descripteur pour un argument d’un objet.

supprimer_valeurs_extremes(x, y, fonction)
xmax
xmin
class wxgeometrie.geolib.courbes.Courbe_generique(**styles)

Classe mère de toutes les courbes.

xarray
yarray
wxgeometrie.geolib.courbes.inf_or_nan(x)
class wxgeometrie.geolib.feuille.Dictionnaire_objets(feuille)

Cette classe est un conteneur pour les objets de la feuille, qui sont tous ses attributs, sauf ceux précédés de __ (attributs reserves pour tous les objets de la classe). Elle contient aussi tous les objets geometriques. Certaines methodes standard (comme __setattr__) sont aussi interceptées ou redefinies.

Attributs spéciaux: _ fait référence au dernier objet enregistré dans la feuille.

_noms_restreints est un dictionnaire contenant une liste de noms ou de patterns qui ne peuvent être associés qu’à certains types d’objets. _noms_interdits est une liste de noms correspondant à des objets en lecture seule. _suppression_impossible est une liste de noms d’objets qui ne peuvent pas être supprimés.

Nota: lorsqu’une clef du dictionnaire est supprimée, la méthode .supprimer() de l’objet est appelée ; les objets qui n’ont pas de méthode .supprimer() sont donc de fait protégés (c’est le cas de pi, e, …), sans qu’il soit nécessaire de les inscrire dans _noms_interdits.

add(valeur, nom_suggere='')

Ajoute l’objet valeur à la feuille.

Si nom_suggere est donné, et que le nom suggéré n’est pas déjà utilisé, l’objet est référencé sous ce nom. Sinon, un nom lui est automatiquement attribué.

clear()

Réinitialise le dictionnaire des objets.

Ne pas utiliser directement, mais utiliser plutôt Feuille.effacer() qui rafraichit correctement l’affichage.

feuille
get(nom, defaut=None)
get_raw_item(nom)

Permet de récupérer les variables elles-mêmes (et non leur contenu).

lister(objets_caches=True, etiquettes=False, **kw)

Retourne la liste des objets géométriques.

Le paramètre objets_caches indique s’il faut inclure les objets cachés.

Le paramètre etiquettes indique s’il faut inclure les étiquettes des objets retournés.

kw: * type : types à inclure * sauf : types à exclure

note:: Utiliser plutôt Feuille.liste_objets(), qui bénéficie d’une mise
en cache des résultats.
noms

Retourne les noms de tous les objets géométriques.

supprimer(*objets)

Supprime plusieurs objets dans le bon ordre.

Supprime successivement plusieurs objets après les avoir classé hiérarchiquement. Cela évite d’avoir des erreurs avec certains objets déjà supprimés avec les précédents du fait des dépendances.

Par exemple, del feuille.objets.A, feuille.objets.B renvoie une erreur si l’objet B dépend de l’objet A, car l’objet B n’existe déjà plus au moment où on cherche à le supprimer.

Nota: La suppression d’un objet qui n’est pas sur la feuille provoque bien toujours une erreur, par contre.

class wxgeometrie.geolib.feuille.Feuille(classeur=None, titre='', log=None, parametres=None, canvas=None)

Feuille de travail.

L’objet “log” doit être une liste destinée à contenir tous les messages.

affichage_perime()

Indique que l’affichage doit être actualisé.

Très rapide (inutile d’optimiser les appels), car aucune actualisation n’a lieu, mais la feuille est juste marquée comme étant à actualiser.

animer(nom, debut=0, fin=1, pas=0.02, periode=0.03)

Anime la variable nommée nom.

Paramètres:
  • nom – nom de la variable dont on souhaite faire varier la valeur.
  • debut – valeur initiale de la variable.
  • fin – valeur finale de la variable.
  • pas – de combien on incrémente la variable à chaque étape.
  • periode – durée (en secondes) entre 2 incrémentations.

nom peut aussi être une expression correspondant à une variable:

>>> from wxgeometrie.geolib import Point, Feuille
>>> f = Feuille()
>>> f.objets.A = A = Point()
>>> f.animer("A.x", 0, 5, .1)
canvas
charger(commandes, rafraichir=True, archiver=True, mode_tolerant=False)

Exécute un ensemble de commandes dans la feuille.

Usage: f = Feuille() … commandes = f.sauvegarder() f.effacer() f.charger(commandes)

coder()

Codage automatique de la figure (longueurs égales, angles égaux, et angles droits).

contient_objet(self, objet) → bool

Teste rapidement si l’objet est répertorié dans la feuille. (Ne cherche pas parmi les objets temporaires.)

contient_objet_temporaire(self, objet) → bool

Teste rapidement si l’objet est répertorié comme objet temporaire dans la feuille.

coo2pix(x, y)

Convertit des coordonnées en pixel.

dcoo2pix(dx, dy)

Convertit un déplacement exprimé en coordonnées en un déplacement en pixels.

dpix2coo(dpx, dpy)

Convertit un déplacement exprimé en pixels en un déplacement exprimé en coordonnées.

effacer()
effacer_codage()

Efface tous les codages sur les segments, angles et arcs de cercles.

effacer_traces()

Efface toutes les traces (sans enlever le mode trace des objets).

erreur(message, erreur=None)
executer(commande, parser=True)
exporter(backend_name, **options)
fenetre_modifiee()
fenetre_reellement_affichee()

Fenêtre réellement affichée à l’écran.

Dans le cas où le ratio abscisse/ordonnée est fixe (par exemple, si l’utilisateur impose un repère orthonormé), les valeurs de xmin, xmax, ymin et ymax définies par l’utilisateur ne peuvent plus correspondre en général à la fenêtre d’affichage réelle (qui élargie dans une des 2 dimensions pour respecter cette contrainte).

Ainsi, Feuille.fenetre renvoie la fenêtre telle que définie par l’utilisateur, tandis que Fenetre.fenetre_reellement_affichee() renvoie la fenêtre réellement affichée à l’écran.

infos(_key_=None, **kw)
inventaire()
lier(action)
liste_objets(objets_caches=None, tri=False, etiquettes=False)

Liste des objets, triés éventuellement selon le style “niveau”.

NB: un système de mise en cache est utilisé si possible, contrairement à .objets.lister().

lister_figures()

Renvoie deux listes de figures (artistes matplotlib).

La seconde est celle des figures qui vont bouger avec l’objet deplacé ; et la première, des autres qui vont rester immobiles.

S’il n’y a pas d’objet en cours de déplacement, la deuxième liste est vide.

message(messg)
met_objets_en_gras(*objets)

Met en gras les objets indiqués, et remet les autres objets en état « normal » le cas échéant.

modifiee
nettoyer()

Supprime les objets cachés inutiles.

Un objet caché est inutile si aucun objet visible ne dépend de lui. Les textes vides sont également supprimés.

nom

Destiné à être affiché.

nom_aleatoire(objet, prefixe=None)

Génère un nom d’objet non encore utilisé.

Si possible, le nom sera de la forme “prefixe” + chiffres. Sinon, un préfixe aléatoire est généré.

nom_complet

Destiné à être affiché en haut de la fenêtre.

objet(nom)
objet_temporaire(objet=False)
parametres
parametres_par_defaut(nom)
pause()
pix2coo(px, py)

Convertit un pixel en coordonnées.

point_temporaire()
redefinir(objet, valeur)
sauvegarder(_as_list=False)

Renvoie l’ensemble des commandes python qui permettra de recréer la figure avec tous ses objets.

La figure pourra ensuite être restaurée à l’aide la commande charger().

Si _as_list=True, renvoie une liste de commandes (par défaut, les lignes de commandes sont concaténées et une chaîne est renvoyée).

Type retourné:string/list
save_log(log)
start()

Autorise le lancement d’animations.

stop()

Arrête toutes les animations en cours.

xmax
xmin
ymax
ymin
class wxgeometrie.geolib.feuille.Historique_feuille(feuille)

Historique de la feuille.

Permet d’enregistrer l’état de la feuille à un instant donné, et de le restaurer ensuite.

annuler()
archiver(signature=None)

Sauvegarde l’état actuel de la feuille.

Notes concernant l’implémentation:

* si l'état de la feuille n'a pas changé depuis la dernière sauvegarde,
  la nouvelle demande de sauvegarde n'est pas prise en compte.
* si `signature` est différente de `None`, une demande effectuée
  avec la même signature que la précédente écrase la précédente.
  Ceci sert essentiellement pour les zooms avec la molette de la souris,
  afin d'éviter de saturer l'historique.
refaire()
restaurer(txt)
class wxgeometrie.geolib.feuille.Interprete_feuille(feuille)

Exécute des commandes dans la feuille.

Reformule également les commandes avant de les exécuter.

commande_executee(signature=None)

Méthode appelée automatiquement après avoir exécuté une commande dans la feuille. Si l’on n’a pas utilisé la méthode executer(), il faut alors l’appeler manuellement.

executer(commande, parser=True, signature=None)

Exécute la commande dans la feuille.

Si parser=False, les facilités de syntaxe (abréviations, etc.) sont désactivées pour plus de rapidité.

Si signature != None, elle est utilisée pour la gestion de l’historique.

Voir aussi commande_executee().

static parser(commande)

Convertit la commande en code Python.

>>> from wxgeometrie.geolib.feuille import Interprete_feuille
>>> Interprete_feuille.parser("[A B]")
'Segment(A, B)'
>>> Interprete_feuille.parser("(A B)")
'Droite(A, B)'
class wxgeometrie.geolib.feuille.Liste_objets(feuille, classe)
class wxgeometrie.geolib.feuille.MethodesObjets(nom_de_la_methode, *objets)
class wxgeometrie.geolib.feuille.ModeTolerant(feuille, mode=True)

Mode d’exécution tolérant aux erreurs. Cela sert essentiellement à charger un fichier d’une ancienne version de WxGéométrie.

wxgeometrie.geolib.feuille.is_equation(chaine)

Teste si une chaîne correspond bien à une équation.

wxgeometrie.geolib.feuille.parse_equation(chaine)

Associe à une équation l’objet géométrique correspondant.

Vérifie que la chaîne est une équation, et retourne une chaîne correspondant à l’objet géométrique correspondant le cas échéant. Sinon, retourne l’objet initial.

class wxgeometrie.geolib.fonctions.Fonction(expression, ensemble='R', variable='x', **styles)

Une fonction.

Une fonction numérique à une variable; l’argument est une expression sous forme de chaine de caractères. Exemple: Fonction(“2*x+1”, variable = “x”, ensemble = “R”).

ensemble
expression
modifier_expression_et_ensemble(expression=None, ensemble=None)

Si l’on modifie à la fois l’expression et l’ensemble, il est beaucoup plus rapide d’utiliser cette méthode.

variable

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

class wxgeometrie.geolib.interpolations.Interpolation_cubique(*points, **styles)

Une interpolation cubique.

Interpolation des points donnés par une courbe polynomiale par morceaux, de vecteur tangent horizontal aux sommets, et de classe C1 en général (ie. si x_n!=x_{n-1}). Pour chaque morceau, x(t)=at^3+bt^2+ct+d et y(t)=et^3+ft^2+gt+h, où t appartient à [0;1], et y”(0)=y”(1)=0.

points

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.interpolations.Interpolation_generique(*points, **styles)

Classe mère de toutes les interpolations.

points

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.interpolations.Interpolation_lineaire(*points, **styles)

Une interpolation linéaire.

Interpolation entre les points donnés par des segments joints (courbe de classe C0).

image_par(transformation)
points

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.interpolations.Interpolation_polynomiale_par_morceaux(*points, **styles)

Une courbe d’interpolation polynomiale par morceaux. Elle utilise l’interpolation par morceau de scipy pour construire la fonction, via la méthode scipy.interpolate.BPoly.from_derivatives()

Elle passe par les points (xl, yl) et avec le nombre derive dans derivl à l’abscisse xl.

exemple:

>>> from wxgeometrie import *
>>> A = Point(-1,-2)
>>> B = Point(2,1)
>>> C = Point(8,-3)
>>> d = Interpolation_polynomiale_par_morceaux(A,B,C, derivees=[-1,0.5,2])
Paramètres:derivee (list) – value of the diff number at each point

:rtype : numpy.lib.polynomial

fonction

Fonction wrapper vers la fonction de scipy BPoly.from_derivatives

points

Un descripteur pour une liste d’arguments d’un objet.

points_tries
strategies = {'moyenne_gauche_droite': <function Interpolation_polynomiale_par_morceaux._strategie_moyenne_gauche_droite at 0x7fad2505a2f0>, 'pente_minimale': <function Interpolation_polynomiale_par_morceaux._strategie_pente_minimale at 0x7fad2505a268>, 'pente_moyenne': <function Interpolation_polynomiale_par_morceaux._strategie_pente_moyenne at 0x7fad2505a1e0>}
xmax
xmin
class wxgeometrie.geolib.interpolations.Interpolation_quadratique(*points, **styles)

Une interpolation quadratique.

Interpolation des points donnés par une courbe polynomiale par morceaux, et de classe C1. Pour chaque morceau, x(t)=at²+bt+c et y(t)=dt²+et+f, où t appartient à [0;1].

points

Un descripteur pour une liste d’arguments d’un objet.

wxgeometrie.geolib.intersections.Intersection(objet1, objet2, **styles)
class wxgeometrie.geolib.intersections.Intersection_cercles(cercle1, cercle2, angle_positif=None, **styles)

Une intersection de cercles.

Un des deux points M et N d’intersection des deux cercles. L’argument angle_positif permet de distinguer les deux points. Si on note A et B les centres respectifs des 2 cercles, l’angle orienté (AB>, AM>) doit être de signe constant.

angle_positif

Un descripteur pour un argument d’un objet.

cercle1

Un descripteur pour un argument d’un objet.

cercle2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.intersections.Intersection_droite_cercle(droite, cercle, premier_point=None, **styles)

Une intersection d’une droite et d’un cercle.

Un des deux points M et N d’intersection d’une droite et d’un cercle. Supposons qu’on le note M, et que la droite soit (AB). L’argument premier_point (optionnel) sert à différencier les deux points d’intersection. Il sert à indiquer si M se trouve « près » de A (1er point de (AB)) ou de B (2ème point). (Plus précisément, si premier_point == True, MA + NB est minimal).

cercle

Un descripteur pour un argument d’un objet.

droite

Un descripteur pour un argument d’un objet.

premier_point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.intersections.Intersection_droites(droite1, droite2, **styles)

Une intersection de droites.

L’intersection de 2 droites, segments, demi-droites…

droite1

Un descripteur pour un argument d’un objet.

droite2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.intersections.Intersection_generique(objet1, objet2, **styles)

Une intersection générique.

La classe mère des différents types d’intersections

intersections

Liste de coordonnées correspondant aux points d’intersections possibles.

Le premier couple correspond aux coordonnées du point lui-même. Attention, tous ces points ne sont pas forcément des points d’intersection. En effet, pour calculer ces intersections, on assimile les segments à des droites, et les arcs à des cercles. Il faut ensuite tester les solutions potentielles avec ._tester_solution().

objet1

Un descripteur pour un argument d’un objet.

objet2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_angle(parent, texte='', **styles)

L’étiquette d’un angle.

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_arc_cercle(parent, texte='', **styles)

L’étiquette d’un arc de cercle.

glisseur

alias de wxgeometrie.geolib.points.Glisseur_arc_cercle

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_cercle(parent, texte='', **styles)

L’étiquette d’un cercle.

glisseur

alias de wxgeometrie.geolib.points.Glisseur_cercle

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_demidroite(parent, texte='', **styles)

L’étiquette d’une demi-droite.

glisseur

alias de wxgeometrie.geolib.points.Glisseur_demidroite

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_droite(parent, texte='', **styles)

L’étiquette d’une droite.

glisseur

alias de wxgeometrie.geolib.points.Glisseur_droite

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_generique(parent, texte='', **styles)

Un label (étiquette accolée à l’objet)

Le label est crée automatiquement lors de la création de l’objet. Le label n’est pas un “vrai” objet, il n’est pas enregistré sur la feuille.

alignement_vertical()

L’alignement vertical du texte (“top”, “bottom” ou “center”).

Pour les objets qui ont une pente (droites, segments), si style(“alignement_vertical”) == “auto”, alors l’alignement retourné est “bottom” si la droite “monte”, et “top” si elle descend.

Ceci est utilisé essentiellement pour les arbres de probabilité.

angle()

L’angle d’affichage du texte.

Pour les objets qui ont une pente (droites, segments), si style(“angle”) == “auto”, alors l’angle retourné est celui correspondant à la pente de l’objet, de sorte que le texte ait la même inclinaison que l’objet.

existe
figure_perimee()
nom
nom_latex
parent

Un descripteur pour un argument d’un objet.

sauvegarder()
texte

Un descripteur pour un argument d’un objet.

visible
x
y
class wxgeometrie.geolib.labels.Label_glisseur(parent, texte='', **styles)

Classe mère de tous les labels utilisant un objet glisseur.

classe doit contenir le type de glisseur utilisé.

glisseur = NotImplemented
parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_point(parent, texte='', **styles)

L’étiquette d’un point.

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_polygone(parent, texte='', **styles)

L’étiquette d’un polygone.

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_segment(parent, texte='', **styles)

L’étiquette d’un segment.

glisseur

alias de wxgeometrie.geolib.points.Glisseur_segment

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.labels.Label_vecteur(parent, texte='', **styles)

L’étiquette d’un vecteur.

glisseur

alias de wxgeometrie.geolib.points.Glisseur_vecteur

parent

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Axe(point1=None, point2=None, **styles)

Un axe orienté.

Un axe orienté servant au repérage. Cette classe sert essentiellement à construire les axes (Ox) et (Oy).

Styles spécifiques: - graduations (bool): afficher ou non les graduations - pas (int|None):

  • entier n (non nul): n fois l’écart entre les deux points repères de l’axe.
  • None ou 0: adapte automatiquement la taille de la graduation à la fenêtre (défaut)
  • pas_num (int): entier positif n:
    • si n est nul, n’affiche aucun nombre sur l’axe ;
    • sinon, affiche un nombre toutes les n graduations (en partant de l’origine de l’axe). En particulier, si pas_num=1, toutes les graduations auront un nombre.
  • repeter (bool): répéter ou non la numérotation sur les axes.
  • hauteur (int): hauteur d’une graduation (en pixels).
  • placement_num (-1|1): position de la numérotation par rapport à l’axe.
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Bissectrice(point1=None, point2=None, point3=None, **styles)

Une bissectrice.

La bissectrice d’un angle défini par 3 points. On peut, au choix, entrer un angle ou 3 points comme argument.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Demidroite(origine=None, point=None, **styles)

Une demi-droite.

Une demi-droite définie par son origine et un deuxième point

equation_formatee

Equation sous forme lisible par l’utilisateur.

image_par(transformation)
origine

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Demiplan(droite=None, point=None, droite_incluse=None, **styles)

Un demi-plan.

Le demi-plan délimité par la droite d et contenant le point M.

droite

Un descripteur pour un argument d’un objet.

droite_incluse

Un descripteur pour un argument d’un objet.

equation_formatee

Equation sous forme lisible par l’utilisateur.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Droite(point1=None, point2=None, **styles)

Une droite.

Une droite définie par deux points

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Droite_equation(a=1, b=-1, c=0, **styles)

Une droite définie par une équation.

Une droite d’équation donnée sous forme d’un triplet (a, b, c). (ax + by + c = 0)

a

Un descripteur pour un argument d’un objet.

b

Un descripteur pour un argument d’un objet.

c

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Droite_generique(point1, point2, **styles)

Une droite générique.

Usage interne : la classe mère pour toutes les droites.

confondu(y)
egal(y)
egale(y)
equation_formatee

Equation sous forme lisible par l’utilisateur.

image_par(transformation)
info
parallele(ligne)

Indique si la ligne est parallèle à une autre ligne.

perpendiculaire(ligne)

Indique si la ligne est perpendiculaire à une autre ligne.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Droite_vectorielle(point=None, vecteur=None, **styles)

Une droite dirigée par un vecteur.

Une droite définie par un point et un vecteur directeur.

point

Un descripteur pour un argument d’un objet.

vecteur

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Ligne_generique(point1, point2, **styles)

Une ligne générique.

Usage interne : la classe mère pour les droites, segments, demi-droites.

angle_affichage()

Angle, à l’écran, de la ligne par rapport l’horizontale, en radians.

copente
equation_reduite

Retourne (a, b) si la droite a une équation de la forme y=ax+b ; et (c,) si la droite a une équation de la forme x=c.

Ceci permet de comparer facilement deux droites, ce qui n’est pas le cas avec la propriété .équation (puisqu’une droite a une infinité d’équations) : si d1._equation_reduite() ~ d2._equation_reduite, d1 et d2 sont (à peu près) confondues.

pente
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

xy(x=None, y=None)

Retourne les coordonnées du point de la droite d’abscisse ou d’ordonnée donnée.

x ou y doivent être définis, mais bien sûr pas les deux.

Nota: Si x est donné pour une droite verticale, un point d’abscisse infinie est retourné. À l’inverse, si y est donné pour une droite horizontale, un point d’ordonnée infinie est retourné.

class wxgeometrie.geolib.lignes.Mediatrice(point1=None, point2=None, **styles)

Une médiatrice.

La médiatrice d’un segment (ou d’un bipoint, …)

>>> from wxgeometrie.geolib import Point, Mediatrice, Segment
>>> A=Point(1,2); B=Point(3,4)
>>> s=Segment(A,B)
>>> Mediatrice(A, B).confondu(Mediatrice(s))
True
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Parallele(droite, point=None, **styles)

Une parallèle.

La parallèle à une droite passant par un point.

droite

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Perpendiculaire(droite, point=None, **styles)

Une perpendiculaire.

Une droite perpendiculaire à une autre passant par un point.

droite

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Point_droite(droite, premier, **styles)

Un des deux points servant à construire une droite d’équation donnée.

Usage interne. Ceci sert pour les droites qui ne sont pas définies à l’aide de points, mais directement à l’aide d’une équation. Comme l’implémentation actuelle des droites exige que la droite soit définie par 2 points, on génère deux points de la droite à partir de son équation.

droite

Un descripteur pour un argument d’un objet.

premier

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

class wxgeometrie.geolib.lignes.Point_tangence(cercle, point, angle_positif=None, **styles)

Un point de tangence.

Le point de tangence d’un cercle et d’une droite tangente au cercle passant par un point donné. Usage interne.

cercle

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Repere(axe1=None, axe2=None, **styles)

Un repère du plan.

Un repère du plan défini par deux axes de même origine.

axe1

Un descripteur pour un argument d’un objet.

axe2

Un descripteur pour un argument d’un objet.

style(nom_style=None, **kw)
class wxgeometrie.geolib.lignes.Segment(point1=None, point2=None, **styles)

Un segment.

Un segment défini par deux points

extremites
image_par(transformation)
info
longueur

Longueur du segment.

Alias de _longueur, disponible pour indiquer que l’objet a vraiment une longueur au sens mathématique du terme (pas comme une droite !)

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Tangente(cercle=None, point=None, angle_positif=None, **styles)

Une tangente.

Une des deux tangentes à un cercle passant par un point extérieur au cercle. Le dernier paramètre (True/False) sert à distinguer les deux tangentes. (Voir la classe Intersection_cercles pour plus d’infos).

angle_positif

Un descripteur pour un argument d’un objet.

cercle

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.lignes.Tangente_glisseur_interpolation(courbe, glisseur=None)

Une tangente à une courbe de type interpolation polynomiale par morceau, et qui glisse.

Le coefficient directeur est estimé par approximation numérique avec taux de variation sur un pas self.__canvas__.pas().

Paramètres:

exemple:

>>> from wxgeometrie import Point, Interpolation_polynomiale_par_morceaux
>>> from wxgeometrie import Glisseur_courbe, Tangente_glisseur_interpolation
>>> A = Point(-1,-2)
>>> B = Point(2,1)
>>> C = Point(8,-3)
>>> d = Interpolation_polynomiale_par_morceaux(A,B,C, derivees=[-1,0.5,2])
>>> P = Glisseur_courbe(d)
>>> d1 = Tangente_glisseur_interpolation(d, P)
courbe

Un descripteur pour un argument d’un objet.

glisseur

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.objet.Argument(types, get_method=None, set_method=None, defaut=None)

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.objet.ArgumentNonModifiable(types, get_method=None, set_method=None)

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

class wxgeometrie.geolib.objet.Arguments(types, get_method=None, set_method=None, defaut=None)

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.objet.BaseArgument(types, get_method=None, set_method=None, defaut=None)

Classe mère des descripteurs “Argument”, “ArgumentNonModifiable” et “Arguments”.

class wxgeometrie.geolib.objet.Cache

Un “dictionnaire” double dont la méthode get est sensiblement modifiée.

Pour chaque entrée, il y a une valeur en mode exact, et une valeur en mode approché.

Si le mot-clé n’existe pas, le dictionnaire est mis à jour à l’aide de la fonction et de ses arguments. À noter que la fonction n’est PAS executée si le dictionnaire contient la clé, ce qui n’est pas le cas de dict.get(clef, fonction(*args, **kw)) bien sûr. D’où l’intérêt du cache.

clear()
get(clef, methode, *args, **kw)
remove(key)

Note: ne renvoie PAS d’erreur si la clé est absente.

class wxgeometrie.geolib.objet.DescripteurFeuille

Descripteur gérant l’attribut “.feuille” de la classe “Objet”.

Usage interne.

class wxgeometrie.geolib.objet.Nom(objet)

Nom d’un objet.

Affiche le nom de l’objet quand on le met sous forme de chaîne.

Exemple : >>> from wxgeometrie.geolib import Nom, Feuille, Point >>> M = Feuille().objets.M = Point(1, 2) >>> nom = Nom(M) >>> nom “M” >>> M.nom = “A” >>> nom “A”

class wxgeometrie.geolib.objet.Objet(**styles)

Un objet géométrique.

La classe Objet est la classe mère de tous les objets géométriques. Note : elle n’est pas utilisable en l’état, mais doit être surclassée.

cacher()
canvas
classmethod classe()
contexte
copier_style(objet=None, **kw)

Applique le style de “objet” à l’objet (self).

Si les objets sont de type différent, seuls certains styles communs entrent en compte.

Exemple:

>>> from wxgeometrie import Point, Segment
>>> A = Point(couleur='b', taille=10)
>>> B = Point()
>>> s = Segment(A, B, couleur='k')
>>> s.copier_style(A)
>>> s.style('couleur')
'b'

Des styles à copier peuvent aussi être ajoutés manuellement (par exemple, couleur=”r”):

>>> C = Point(couleur='r', taille=12)
>>> C.copier_style(A, couleur='g')
>>> C.style('couleur')
'g'
>>> C.style('taille')
10

Seuls les styles ayant du sens pour ce type d’objet seront appliqués.

copy()
definition

Définition en français correct de l’objet.

Exemple: “Perpendiculaire à d passant par M”

distance_inf(x, y, d)

Teste si la distance (à l’ecran, en pixels) entre l’objet et (x, y) est inférieure à d.

effacer_trace()
en_gras(valeur=True)

Met en valeur un objet.

Typiquement, il s’agit d’un objet sélectionné.

Si l’objet a été mis en gras, retourne True. S’il a été remis en état « normal », retourne False. Si l’état de l’objet n’a pas changé, retourne None.

erreur(message)
espace_vital
existe
feuille

Descripteur gérant l’attribut “.feuille” de la classe “Objet”.

Usage interne.

figure

La représentation graphique associée à l’objet.

La figure est une liste d’objets graphiques pour matplotlib : tous les items de la liste sont du type matplotlib.artist.Artist.

La figure bénéficie d’un système de cache : elle n’est pas recrée à chaque fois, mais seulement lorsqu’elle a été marquée comme périmée. La méthode interne ._creer_figure()

figure_perimee()

Indique que la figure doit être rafraichie.

Est appelé directement lorsque le style de l’objet est modifié, mais pas ses arguments. (Par ex., le point change de couleur, mais pas de coordonnées). Sinon, il faut appeler la méthode Objet.perime(), qui effectue un rafraichissement global de l’objet (figure inclue).

classmethod genre()
identifiers = <WeakValueDictionary>
info

À surclasser, en donnant une information significative pour l’objet.

Par exemple, pour un point ou un vecteur, ses coordonnées, pour un segment, sa longueur, pour un polygone, son aire…

label(*args, **kw)

Affiche le label (ou etiquette) de l’objet.

Suivant le mode en vigueur, il peut s’agir du nom de l’objet, éventuellement formaté en LaTeX, ou d’un texte associé à l’objet:

>>> from wxgeometrie import *
>>> f = Feuille()

>>> A = f.objets.A = Point(-2.7, 3.1)
>>> A.label()
'$A$'

>>> B = f.objets.B = Point(4.8, 6.5)
>>> D1 = f.objets.D1 = Droite(A, B)
>>> D1.label()
''

>>> D1.label(mode='nom')
>>> print(D1.label())
$\mathscr{D}_{1}$

>>> D1.label("Je suis une droite.")
>>> print(D1.label())
Je suis une droite.

Si le texte contient des formules entre accolades, elles peuvent également être interprétées, si le mode “formule” est activé:

>>> D1.label("A a pour abscisse {A.x}.", mode='formule')
>>> D1.label()
u'A a pour abscisse -2,7.'
static latex_police_cursive(nom)
legende

Renvoie le texte brut associé à l’objet.

Permet d’avoir une interface unique pour les objets avec étiquette, et les textes (qui sont eux-mêmes leur propre étiquette en quelque sorte), qui surclassent cette méthode.

Pour obtenir le texte formaté (en fonction du mode d’affichage), utiliser la méthode .label().

Note:

Le mode d’affichage est accessible via l’attribut .mode_affichage.

message(message)
mode_affichage

Assure une interface commune entre les objets avec étiquette et les textes.

nom
nom_complet
nom_corrige

Renvoie le nom en remplaçant, le cas échéant, _prime par un guillemet simple (“).

on_register()

Actions à effectuer lorsque l’objet est enregistré dans la feuille.

::note:

"Enregistré" signifie que l'objet est explicitement référencé dans la

feuille (il a un nom, et apparaît généralement sur le graphique).

Cette méthode provoque l’enregistrement sur la feuille des arguments de l’objet, dans le cas où ceux-ci sont des valeurs par défaut.

À surclasser éventuellement.

perime(_first_call=True)

Marquer l’objet comme à actualiser.

  • indique que les coordonnées/valeurs de l’objet et des ses héritiers doivent être recalculées,
  • indique que les figures de l’objet et de ses héritiers doivent être redessinnées.
  • actualise la liste des ancêtres de l’objet (au cas où un argument ait été modifié).

Note

ne pas modifier la valeur du paramètre _first_call, qui est purement à usage interne (appels récursifs).

redefinir(valeur)
renommer(nom, afficher_nom=None, **kw)

Permet de renommer l’objet, et éventuellement de changer en même temps son style.

sauvegarder()

Retourne le code python nécessaire pour générer l’objet.

Cette méthode est utilisée par la feuille pour sauvegarder son contenu.

Type retourné:string
static souffler()

Indique au système qu’il faut exécuter les évènements en attente.

Ceci est utile en particulier pour rafraîchir l’affichage dans une boucle, lorsque geolib est appelé depuis une interface graphique. Cela permet de faire des animations dans « geler » l’affichage.

Cette méthode est statique, et doit être modifiée par le gestionnaire d’affichage:

Objet.souffler = ma_methode

Par exemple, pour pyQt:

Objet.souffler = QCoreApplication.processEvents

ou pour WxPython:

Objet.souffler = wx.YieldIfNeeded
style(nom_style=None, **kw)

Renvoie le ou les styles demandés, ou modifie les styles de l’objet.

Paramètres:
  • nom_style – un nom de style, ou une liste de noms de styles.
  • **kw –

    sert à modifier des styles.

Exemple d’utilisation:

>>> from wxgeometrie import Point
>>> A = Point(couleur='blue', taille=25)
>>> A.style(['couleur', 'taille'])
['blue', 25]

On change la couleur (le nouveau dictionnaire de styles est renvoyé):

>>> styles = A.style(couleur = 'green')
>>> styles['couleur']
'green'
>>> A.style('couleur')
'green'
Note:les propriétés sont stockées en interne dans self._style.
supprimer()

Supprime l’objet de la feuille.

classmethod titre(article='un', point_final=True)

Affichage formaté du type de l’objet… (un peu de grammaire!). Article peut être “un”, “le”, ou “du”, l’accord se faisant automatiquement. Le formatage est respecté (essayez “un”, “UN”, “Un”).

>>> from wxgeometrie.geolib.vecteurs import Vecteur_libre
>>> u = Vecteur_libre()
>>> print u.titre()
un vecteur libre.
titre_complet(article='un', point_final=False)
classmethod type()
verrou = <wxgeometrie.geolib.objet.Verrou object>
visible
voir()
class wxgeometrie.geolib.objet.ObjetType
class wxgeometrie.geolib.objet.Objet_avec_coordonnees(**styles)

Un objet ayant des coordonnées (ex: points, vecteurs, …).

Usage interne : permet aux objets en héritant d’offrir un accès facile pour l’utilisateur final aux coordonnées via __call__.

coordonnees
coordonnees_approchees
info
xy
class wxgeometrie.geolib.objet.Objet_avec_coordonnees_modifiables(x=None, y=None, **styles)

Un objet ayant des coordonnées (ex: points libres, vecteurs libres, textes…).

Usage interne.

abscisse

Un descripteur pour un argument d’un objet.

affixe
ordonnee

Un descripteur pour un argument d’un objet.

x

Un descripteur pour un argument d’un objet.

y

Un descripteur pour un argument d’un objet.

z
class wxgeometrie.geolib.objet.Objet_avec_equation(**styles)

Un objet contenant une équation (ex: droites, …).

Usage interne : permet aux objets en héritant d’offrir un accès facile pour l’utilisateur final à cette valeur via __call__.

equation
equation_approchee
class wxgeometrie.geolib.objet.Objet_avec_valeur(**styles)

Un objet contenant une valeur numérique (ex: angles, variables, …).

Usage interne : permet aux objets en héritant d’offrir un accès facile pour l’utilisateur final à cette valeur via __call__. Gère le mode approché et la mise en cache.

val
valeur
valeur_approchee
class wxgeometrie.geolib.objet.Ref

Conteneur pour un argument d’un objet.

Si l’objet est déjà une instance de Reference, alors l’objet est renvoyé directement (afin de ne pas créer de conteneur de conteneur !)

La référence est manipulée ensuite via un descripteur (de type BaseArgument), et jamais directement, ce qui explique qu’elle n’ait pas de méthode publique.

Attributs: * __objet: l’objet contenu * _utilisateurs: les objets qui partagent cette même référence en argument.

objet
class wxgeometrie.geolib.objet.Rendu(parent)

Couche d’abstraction entre l’objet et le canvas.

Son rôle est de rendre l’objet plus indépendant du canvas, mais aussi de faciliter le débogage, en indiquant quel objet a dessiné quoi.

angle(*args, **kw)
arc(*args, **kw)
canvas
cercle(*args, **kw)
codage(*args, **kw)
codage_angle(*args, **kw)
decoration_texte(*args, **kw)
feuille
fleche(*args, **kw)
fleche_courbe(*args, **kw)
ligne(*args, **kw)
lignes(*args, **kw)
point(*args, **kw)
polygone(*args, **kw)
rectangle(*args, **kw)
texte(*args, **kw)
class wxgeometrie.geolib.objet.TupleObjets

Un objet tuple personnalisé, destiné à contenir des objets géométriques.

Usage interne.

class wxgeometrie.geolib.objet.Verrou

Verrouille la mise à jour des objets.

Pour des raisons d’optimisation, il vaut mieux globaliser la mise à jour des objets, autant que possible, plutôt que de faire plusieurs mises à jours séparées, sachant que certains objets peuvent avoir des héritiers communs qui seraient alors mis à jour plusieurs fois.

Dans ce cas, on peut exécuter un ensemble de commandes dans un contexte VerrouObjet, ce qui bloque toutes les mises, qui auront lieu lorsqu’on sortira du contexte. Si plusieurs mises à jours sur un même objet sont demandées, une seule sera effectuée.

NB: Si le verrouillage est demandé, alors qu’un verrouillage est déjà en cours, cela n’a aucun effet.

locked

Indique si le verrouillage est en cours.

update_later(objet, actualiser_parents)

Indique que l’objet devra être rafraichi lorsque le verrouillage prendra fin.

wxgeometrie.geolib.objet.issympy(*expressions)
class wxgeometrie.geolib.points.Barycentre(*points_ponderes, **styles)

Un barycentre.

Un barycentre de n points.

points_ponderes

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.points.Centre(cercle, **styles)

Un centre de cercle.

cercle

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Centre_cercle_circonscrit(triangle, **styles)

Un centre du cercle circonscrit.

Centre du cercle circonscrit d’un triangle (intersection des médiatrices).

triangle

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Centre_cercle_inscrit(triangle, **styles)

Un centre du cercle inscrit.

Centre du cercle inscrit d’un triangle (intersection des bissectrices).

triangle

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Centre_gravite(polygone, **styles)

Un centre de gravité.

Centre de gravité d’un polygone (l’intersection des médianes dans le cas d’un triangle).

polygone

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Centre_polygone_generique(polygone, **styles)

Un centre d’un triangle.

Classe mère des différents centres d’un triangle.

class wxgeometrie.geolib.points.Glisseur_arc_cercle(arc, k=None, **styles)

Un point sur un arc de cercle.

Point pouvant “glisser” sur un cercle. k est un angle. Si O et r sont les centres et rayons de l’arc, k un coefficient compris entre 0 et 1, et a et b les mesures d’angle marquant le début et la fin de l’arc, les coordonnées du glisseur M seront déterminées par la formule M = O + r*(cos(ka+(1-k)b), sin(ka+(1-k)b)), si l’arc est de sens direct, et M = O + r*(cos(kb+(1-k)a), sin(kb+(1-k)a)) sinon.

arc

Un descripteur pour un argument d’un objet.

k

Un descripteur pour un argument d’un objet.

parametre

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Glisseur_cercle(cercle, k=None, **styles)

Un point sur un cercle.

Point pouvant “glisser” sur un cercle. k est un angle. Si O et r sont les centres et rayons du cercle, k l’angle, les coordonnées du glisseur M seront déterminées par la formule M = O + r*(cos(k), sin(k)).

cercle

Un descripteur pour un argument d’un objet.

k

Un descripteur pour un argument d’un objet.

parametre

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Glisseur_courbe(courbe, x=None, **styles)

Un point sur une courbe.

Point pouvant “glisser” sur une courbe d’interpolation ou de fonction:

>>> from wxgeometrie import Glisseur_courbe, Courbe, Feuille
>>> f = Feuille()
>>> c = f.objets.c = Courbe("x^2")
>>> G = Glisseur_courbe(c, x=-2)
>>> G.y

4.0 >>> G.x = 5 >>> G.y 25.0

courbe

Un descripteur pour un argument d’un objet.

parametre

Un descripteur pour un argument d’un objet.

x

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Glisseur_demidroite(demidroite, k=None, **styles)

Un point sur une demi-droite.

Point pouvant “glisser” sur un segment. k est un coefficient barycentrique. Si A et B sont les deux points de référence de la droite, k le coefficient, les coordonnées du glisseur M seront determinées par la formule M = kA + (1-k)B.

demidroite

Un descripteur pour un argument d’un objet.

k

Un descripteur pour un argument d’un objet.

parametre

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Glisseur_droite(droite, k=None, **styles)

Un point sur une droite.

Point pouvant “glisser” sur une droite. k est un coefficient barycentrique. Si A et B sont les deux points de référence de la droite, k le coefficient, les coordonnées du glisseur M seront determinées par la formule M = kA + (1-k)B.

droite

Un descripteur pour un argument d’un objet.

k

Un descripteur pour un argument d’un objet.

parametre

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Glisseur_generique(objet, k, **styles)

Un glisseur générique.

Classe mère des différents types de glisseurs

k

Un descripteur pour un argument d’un objet.

objet

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Glisseur_ligne_generique(ligne, k, **styles)

Un glisseur générique sur ligne.

Classe mère des différents types de glisseurs sur ligne (ie. droite, segment, demi-droite)

k

Un descripteur pour un argument d’un objet.

ligne

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Glisseur_segment(segment, k=None, **styles)

Un point sur un segment.

Point pouvant “glisser” sur un segment. k est un coefficient barycentrique. Si A et B sont les deux points de référence de la droite, k le coefficient, les coordonnées du glisseur M seront determinées par la formule M = kA + (1-k)B.

k

Un descripteur pour un argument d’un objet.

parametre

Un descripteur pour un argument d’un objet.

segment

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Glisseur_vecteur(vecteur, k=None, **styles)

Un glisseur sur vecteur.

k

Un descripteur pour un argument d’un objet.

parametre

Un descripteur pour un argument d’un objet.

vecteur

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Milieu(point1=None, point2=None, **styles)

Un milieu.

Le milieu de 2 points

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Nuage(*points, **styles)

Un nuage de points.

Le nuage est défini par la donnée de ses points.

points

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.points.NuageFonction(fonction, *abscisses, **styles)

Un nuage de points de coordonnées (x; f(x)).

Le nuage est défini par la donnée de la fonction f, et d’une liste d’abscisses.

abscisses

Un descripteur pour une liste d’arguments d’un objet.

fonction

Un descripteur pour un argument d’un objet.

points
class wxgeometrie.geolib.points.Nuage_generique(**styles)

Un nuage de points generique.

Usage interne : la classe mère de tous les nuages de points.

points
style(nom_style=None, **kwargs)
class wxgeometrie.geolib.points.Orthocentre(triangle, **styles)

Un orthocentre.

Orthocentre d’un triangle (intersection des hauteurs).

triangle

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Point(x=None, y=None, **styles)

Un point libre.

>>> from wxgeometrie.geolib import Point
>>> A = Point(7, 3)
>>> print A
Point(x = 7, y = 3)
abscisse

Un descripteur pour un argument d’un objet.

ordonnee

Un descripteur pour un argument d’un objet.

x

Un descripteur pour un argument d’un objet.

y

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Point_equidistant(point1, point2, point3, **styles)

Point équidistant de 3 points.

Utilisé surtout pour un usage interne, le calcul des coordonnées est plus rapide qu’en passant par les médiatrices.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Point_final(depart=None, vecteurs=(), coefficients=None, **styles)

Un point défini par une relation vectorielle.

Point défini par une relation vectorielle.
-> -> ->

Exemple : point N tel que AN = -3 AB + 2 BC N = Point_final(A, [A>B, B>C], [-3,2])

coefficients

Un descripteur pour une liste d’arguments d’un objet.

coeffs

Un descripteur pour une liste d’arguments d’un objet.

depart

Un descripteur pour un argument d’un objet.

vecteurs

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.points.Point_generique(**styles)

Un point générique.

Usage interne : la classe mère pour tous les types de points (libres, barycentres, intersection…).

abscisse
affixe
confondu(*points)
distinct(*points)
egal(*points)
egale(*points)
image_par(transformation)
ordonnee
relier_axe_x()
relier_axe_y()
relier_axes()
x
y
z
class wxgeometrie.geolib.points.Point_homothetie(point, homothetie, **styles)

Une image d’un point par homothétie.

Point construit à partir d’un autre via une homothétie de rapport et de centre donné.

homothetie

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Point_interpolation(point=None, derivee=None, **styles)

Un point avec une pente associée.

Usage interne : les points d’interpolation sont utilisés pour la construction des courbes d’interpolation.

derivee

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Point_pondere(point=None, coefficient=None, **styles)

Un point pondéré.

Usage interne : les points pondérés sont utilisés dans la définition des barycentres.

coefficient

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Point_reflexion(point, reflexion, **styles)

Une image d’un point par réflexion.

Point construit à partir d’un autre via une symétrie d’axe donné.

point

Un descripteur pour un argument d’un objet.

reflexion

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Point_rotation(point, rotation, **styles)

Une image d’un point par rotation.

Point construit à partir d’un autre via une rotation d’angle et de centre donné.

point

Un descripteur pour un argument d’un objet.

rotation

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Point_translation(point, translation, **styles)

Une image d’un point par translation.

point

Un descripteur pour un argument d’un objet.

translation

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Projete_arc_cercle(point, arc, **styles)

Un projeté orthogonal sur un arc de cercle.

Projeté orthogonal d’un point sur un arc de cercle.

arc

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Projete_cercle(point, cercle, **styles)

Un projeté orthogonal sur un cercle.

Projeté orthogonal d’un point sur un cercle.

cercle

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Projete_demidroite(point, demidroite, **styles)

Un projeté orthogonal sur une demi-droite.

Projeté orthogonal d’un point sur une demi-droite.

demidroite

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Projete_droite(point, droite, **styles)

Un projeté orthogonal sur une droite.

Projeté orthogonal d’un point sur une droite.

droite

Un descripteur pour un argument d’un objet.

point

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.points.Projete_generique(point, objet, **styles)

Un projeté générique.

Classe mère des différents types de projetés orthogonaux (sur droite, sur cercle ou sur segment).

distance
class wxgeometrie.geolib.points.Projete_segment(point, segment, **styles)

Un projeté orthogonal sur un segment.

Projeté orthogonal d’un point sur un segment.

point

Un descripteur pour un argument d’un objet.

segment

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polyedres.Arete(polyedre, n, p, **styles)

Une arête.

Une arête d’un polyèdre, reliant le point numero “n” au point numero “p”. Note: n et p commencent à 0. L’objet est créé automatiquement lors de la création du polyèdre. De plus, si l’objet est supprimé, le polyèdre est automatiquement supprimé.

cachee
n

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

p

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

polyedre

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

supprimer()
class wxgeometrie.geolib.polyedres.Cube(point1=None, point2=None, angle=None, rapport=None, **styles)

Un cube.

La projection d’un cube.

angle

Un descripteur pour un argument d’un objet.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

rapport

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polyedres.Polyedre_generique(*points, **styles)

Un polyèdre générique.

Classe mère de toutes les représentations de polyèdres.

aretes
centre
centre_gravite
on_register()

Enregistre les arêtes et les sommets du polyedre dans la feuille lors de l’enregistrement du polyedre.

points

Un descripteur pour une liste d’arguments d’un objet.

sommets
class wxgeometrie.geolib.polyedres.Sommet_cube(point1, point2, angle, rapport, **styles)

Un sommet d’un rectangle.

(Usage interne).

angle

Un descripteur pour un argument d’un objet.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

rapport

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polyedres.Sommet_polyedre(polyedre, n, **styles)

Un sommet.

Le nième sommet d’un polyèdre. Note: n commence à 0. L’objet est créé automatiquement lors de la création du polyedre. De plus, si l’objet est supprimé, le polyèdre est automatiquement supprimé.

n

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

polyedre

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

class wxgeometrie.geolib.polyedres.Tetraedre(point1=None, point2=None, point3=None, point4=None, **styles)

Un tétraèdre.

La projection d’un tétraèdre.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

point4

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Carre(point1=None, point2=None, **styles)

Un carré.

Un carré défini par deux points consécutif (sens direct).

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Carre_centre(centre=None, sommet=None, **styles)

Un carré.

Un carré défini par son centre et un sommet.

centre

Un descripteur pour un argument d’un objet.

sommet

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Cote(polygone, n, **styles)

Un coté.

Un coté d’un polygone, reliant le point numero “n” au point numero “n + 1”. Note: n commence à 0. L’objet est créé automatiquement lors de la création du polygone. De plus, si l’objet est supprimé, le polygone est automatiquement supprimé.

n

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

polygone

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

supprimer()

Supprime le polygone auquel appartient le côté.

..note::
Il n’y a aucun intérêt à supprimer uniquement le côté (d’autant qu’un côté supprimé ne peut pas facilement être rétabli), et si un côté est supprimé sans le polygone, on a parfois l’impression d’un bug (impossible de placer un point sur le côté par exemple).
class wxgeometrie.geolib.polygones.Heptagone(point1=None, point2=None, point3=None, point4=None, point5=None, point6=None, point7=None, **styles)

Un heptagone.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

point4

Un descripteur pour un argument d’un objet.

point5

Un descripteur pour un argument d’un objet.

point6

Un descripteur pour un argument d’un objet.

point7

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Hexagone(point1=None, point2=None, point3=None, point4=None, point5=None, point6=None, **styles)

Un hexagone.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

point4

Un descripteur pour un argument d’un objet.

point5

Un descripteur pour un argument d’un objet.

point6

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Losange(point1=None, point2=None, angle=None, **styles)

Un losange.

angle

Un descripteur pour un argument d’un objet.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Octogone(point1=None, point2=None, point3=None, point4=None, point5=None, point6=None, point7=None, point8=None, **styles)

Un octogone.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

point4

Un descripteur pour un argument d’un objet.

point5

Un descripteur pour un argument d’un objet.

point6

Un descripteur pour un argument d’un objet.

point7

Un descripteur pour un argument d’un objet.

point8

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Parallelogramme(point1=None, point2=None, point3=None, **styles)

Un parallélogramme.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Pentagone(point1=None, point2=None, point3=None, point4=None, point5=None, **styles)

Un pentagone.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

point4

Un descripteur pour un argument d’un objet.

point5

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Polygone(*points, **styles)

Un polygone.

Un polygone défini par ses sommets.

on_register()
points

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.polygones.Polygone_generique(*points, **styles)

Un polygone générique.

Classe mère de tous les polygones.

aire

D’après David Chandler, Area of a general polygon. http://www.davidchandler.com/AreaOfAGeneralPolygon.pdf

centre
centre_gravite
convexe
cotes
equilateral
image_par(transformation)
info
inscrit

Le polygone est-il inscrit dans un cercle ?

on_register()

Enregistre les côtés et les sommets du polygone dans la feuille lors de l’enregistrement du polygone.

perimetre
points

Un descripteur pour une liste d’arguments d’un objet.

regulier
sommets
class wxgeometrie.geolib.polygones.Polygone_regulier(point1=None, point2=None, n=6, **styles)

Un polygone régulier.

Un polygone régulier défini par deux points consécutif (sens direct).

centre
n

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Polygone_regulier_centre(centre=None, sommet=None, n=None, **styles)

Un polygone régulier.

Un polygone régulier défini par son centre, un sommet, et le nombre de côtés.

centre

Un descripteur pour un argument d’un objet.

n

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

sommet

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.PrevisualisationPolygone(*points)

Une forme de polygone utilisée uniquement pour la prévisualisation.

Usage interne.

feuille = None
points
style(nom)
class wxgeometrie.geolib.polygones.Quadrilatere(point1=None, point2=None, point3=None, point4=None, **styles)

Un quadrilatère.

carre
croise
losange
parallelogramme
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

point4

Un descripteur pour un argument d’un objet.

rectangle
trapeze
class wxgeometrie.geolib.polygones.Rectangle(point1=None, point2=None, rapport=None, **styles)

Un rectangle.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

rapport

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Sommet(polygone, n, **styles)

Un sommet.

Le nième sommet d’un polygone.

Note

n commence à 0.

L’objet est créé automatiquement lors de la création du polygone. De plus, si l’objet est supprimé, le polygone est automatiquement supprimé.

n

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

polygone

Un descripteur pour un argument non modifiable d’un objet.

Note : un argument non modifiable n’est pas encapsulé dans un objet “Ref”.

supprimer()

Supprime le polygone auquel appartient le sommet.

Note

Il n’y a aucun intérêt à supprimer uniquement le sommet (d’autant qu’un sommet supprimé ne peut pas facilement être rétabli).

class wxgeometrie.geolib.polygones.Sommet_rectangle(point1, point2, rapport, **styles)

Un sommet d’un rectangle.

(Usage interne).

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

rapport

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Sommet_triangle_isocele(sommet_principal, point2, angle, **styles)

Un sommet d’un triangle isocèle.

Le 3e sommet du triangle isocele (un des sommets de la base). (Usage interne).

angle

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

sommet_principal

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Sommet_triangle_rectangle(point1, point2, angle, **styles)

Un sommet d’un triangle rectangle.

Le sommet opposé à l’hypothénuse du triangle rectangle. (Usage interne).

angle

Un descripteur pour un argument d’un objet.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Triangle(point1=None, point2=None, point3=None, **styles)

Un triangle.

convexe
inscrit

Le polygone est-il inscrit dans un cercle ?

isocele
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

point3

Un descripteur pour un argument d’un objet.

rectangle
regulier
class wxgeometrie.geolib.polygones.Triangle_equilateral(point1=None, point2=None, **styles)

Un triangle équilatéral.

Un triangle équilatéral défini par deux points consécutif (sens direct).

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Triangle_equilateral_centre(centre=None, sommet=None, **styles)

Un triangle équilatéral.

Un triangle équilatéral défini par son centre et un sommet.

centre

Un descripteur pour un argument d’un objet.

sommet

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Triangle_isocele(sommet_principal=None, point2=None, angle=None, **styles)

Un triangle isocèle.

Un triangle isocèle défini par son sommet principal, un autre sommet, et son angle principal (sens direct).

angle

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

sommet_principal

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Triangle_isocele_rectangle(point1=None, point2=None, **styles)

Un triangle isocèle rectangle.

Un triangle isocèle rectangle défini par les extrémités de son hypothénuse (sens direct).

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.polygones.Triangle_rectangle(point1=None, point2=None, angle=None, **styles)

Un triangle rectangle.

Un triangle rectangle défini par les extrémités de son hypothénuse (sens direct), et un de ses angles aigus.

angle

Un descripteur pour un argument d’un objet.

point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.pseudo_canvas.PseudoCanvas

Faux canvas utilisé par défaut par la feuille de travail.

Permet de faire appel à l’objet canvas et à ses méthodes sans générer d’erreur lorsqu’il n’y a pas de canvas.

geler_affichage(*args, **kw)
class wxgeometrie.geolib.pseudo_canvas.PseudoContexte

Contexte bidon ne faisant absolument rien.

wxgeometrie.geolib.routines.angle_vectoriel(u, v)

Renvoie une mesure sur ]-pi;pi] de l’angle formé par les vecteurs u et v. u et v doivent être de type list, tuple, array, ou geolib.Vecteur, et de dimension 2.

Version compatible avec sympy.

wxgeometrie.geolib.routines.array_zip(*args)
wxgeometrie.geolib.routines.arrondir(x)

Arrondi le nombre : un seul chiffre significatif, compris entre 1 et 5. Transforme automatiquement le nombre en entier selon le cas.

wxgeometrie.geolib.routines.arrondir_1_25_5(x)

Arrondit x à un nombre de la forme k*10^p, avec k dans {1, 2.5, 5}, et p entier relatif.

>>> from wxgeometrie.geolib.routines import arrondir_1_25_5
>>> arrondir_1_25_5(200)
250.0
>>> arrondir_1_25_5(4527)
5000.0
>>> arrondir_1_25_5(0.0078)
0.01
wxgeometrie.geolib.routines.arrondir_1_2_5(x)

Arrondit x à un nombre de la forme k*10^p, avec k dans {1, 2, 5}, et p entier relatif.

>>> from wxgeometrie.geolib.routines import arrondir_1_2_5
>>> arrondir_1_2_5(250)
200.0
>>> arrondir_1_2_5(4527)
5000.0
>>> arrondir_1_2_5(0.0078)
0.01
wxgeometrie.geolib.routines.carre_distance(A, B)

Carré de la distance entre les points A et B.

wxgeometrie.geolib.routines.carre_distance_point_ellipse(centre, rx, ry, point, epsilon=None)

Distance approchée entre un point et une ellipse orientée selon les axes.

Algorithme naïf, d’après moi-même. ;-)

wxgeometrie.geolib.routines.confondus(M, N)
wxgeometrie.geolib.routines.delta(a, b, c)
wxgeometrie.geolib.routines.det(vec1, vec2)

Déterminant de deux vecteurs du plan.

wxgeometrie.geolib.routines.direction_droite(pi, pj, pk)
wxgeometrie.geolib.routines.distance(A, B)

Distance entre les points A et B.

wxgeometrie.geolib.routines.distance_segment(M, A, B, d)

Teste si la distance entre le point M et le segment [AB] est inférieure à d.

M, A et B sont des couples de réels, et d un réel. Cf. « distance_point_segment.odt » dans « developpeurs/maths/ ».

wxgeometrie.geolib.routines.distincts(M, N)
wxgeometrie.geolib.routines.distincts2a2(*points)
wxgeometrie.geolib.routines.enveloppe_convexe(*points)

Donne l’enveloppe convexe d’un ensemble de points. D’après Dinu C. Gherman (Andrew’s Monotone Chain Algorithm).

wxgeometrie.geolib.routines.formatage(eqn)

Améliore l’affichage des équations.

>>> from wxgeometrie.geolib.routines import formatage
>>> formatage('1 x + -1/3 y + 1 = 0')
'x - 1/3 y + 1 = 0'
>>> formatage('-1 x + -1 y + -1 = 0')
'-x - y - 1 = 0'
>>> formatage('2 x + 0 y - 28 = 0')
'2 x - 28 = 0'
>>> formatage(u'x² + y² + -1 x + -4/3 y + -47/36 = 0') == u'x² + y² - x - 4/3 y - 47/36 = 0'
True
wxgeometrie.geolib.routines.nchiffres(x, n=1)

Arrondi x en fournissant n chiffres significatifs.

>>> from wxgeometrie.geolib.routines import nchiffres
>>> nchiffres(2345, 2)
2300.0
wxgeometrie.geolib.routines.nice_display(x)
wxgeometrie.geolib.routines.nice_str(x)

Convertit en chaîne de caractères les objets mathématiques.

Améliore le formatage de ces objets:

  • Supprime les 0 inutiles.

    >>> from wxgeometrie.geolib.routines import nice_str
>>> nice_str(8.0)
'8'

  • Remplace le point par une virgule pour les décimaux.

    >>> nice_str(8.2)
'8,2'

  • Personnalise un peu l’affichage de certains objets sympy, pour correspndre aux notations française.

    >>> from sympy import oo, log
>>> nice_str(oo)
'+oo'
>>> nice_str(log(7))
'ln(7)'
wxgeometrie.geolib.routines.norme(x, y)

Implémentation rapide de la norme d’un vecteur.

wxgeometrie.geolib.routines.point_dans_enveloppe_convexe(point, polygone)

Détermine si un point est à l’intérieur de l’enveloppe convexe d’un polygone.

wxgeometrie.geolib.routines.point_dans_polygone(couple, polygone)

Détermine si un point est à l’intérieur d’un polygone. D’après un algorithme de Paul Bourke.

wxgeometrie.geolib.routines.produit_scalaire(u, v)

Calcule le produit scalaire des vecteurs u et v. u et v doivent être de type list, tuple, array, ou geolib.Vecteur.

wxgeometrie.geolib.routines.racines(a, b, c, exact=False)
wxgeometrie.geolib.routines.radian(val)
wxgeometrie.geolib.routines.segments_secants(p1, p2, p3, p4)
wxgeometrie.geolib.routines.strip_trailing_zeros(s)

« Supprime tous les zeros inutiles des nombres flottants.

>>> from wxgeometrie.geolib.routines import strip_trailing_zeros
>>> strip_trailing_zeros("4.0000")
'4'
>>> strip_trailing_zeros("4.200*x + 3.007*y + 5.0*z + .010 = 0")
'4.2*x + 3.007*y + 5*z + .01 = 0'
wxgeometrie.geolib.routines.trigshift(t, a=0)

Retourne le représentant de t[2pi] situé dans l’intervalle [a; a+2pi[.

wxgeometrie.geolib.routines.vect(A, B)

Coordonnées du vecteur A>B.

class wxgeometrie.geolib.textes.Texte(texte='', x=None, y=None, **styles)

Un texte.

Un texte à afficher

abscisse

Un descripteur pour un argument d’un objet.

image_par(transformation)
ordonnee

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

x

Un descripteur pour un argument d’un objet.

y

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.textes.Texte_editable_generique(texte='', **styles)

Un texte éditable générique.

La classe mère de tous les textes éditables. (Usage interne).

formule
label(texte=None, mode=None)

Affiche ou modifie le label (ou étiquette) de l’objet.

Si texte ou mode est spécifié, modifie le contenu du texte, et/ou le mode associé, et ne renvoie rien (None).

(Si aucun mode n’est spécifié, le mode est fixé à “texte”.)

Sinon, renvoie le label de l’objet.

La signification de la chaine renvoyée dépendra du mode d’affichage de l’objet:

- si mode = 'rien', renvoie ''
- si mode = ''nom'', renvoie le nom de l'objet
- si mode = 'texte', renvoie le label proprement dit de l'objet
- si mode = 'formule', renvoie le label interprété comme une formule

Note:

Le mode d’affichage est accessible en lecture seule via l’attribut .mode_affichage, et le texte interne (non formaté) via l’attribut .legende.

legende

Renvoie le texte brut associé à l’objet.

Permet d’avoir une interface unique pour les objets avec étiquette, et les textes (qui sont eux-mêmes leur propre étiquette en quelque sorte), qui surclassent cette méthode.

mode_affichage

Assure une interface commune entre les objets avec étiquette et les textes.

style(nom_style=None, **kw)

Renvoie le ou les styles demandés, ou modifie les styles de l’objet.

  • nom_style est un nom de style, ou une liste de noms de styles:

La propriété correspondante est recherchée dans self._style. Ex: couleur, taille = A.style((“couleur”, “taille”))

  • **kw sert à modifier des styles.

Ex: A.style(couleur = “blue”)

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.textes.Texte_generique(**styles)

Un texte générique.

La classe mère de tous les objets Texte. (Usage interne).

alignement_vertical()

Angle du texte.

À surclasser éventuellement pour implémenter un mode “auto”.

angle()

Angle du texte.

À surclasser éventuellement pour implémenter un mode “auto”.

encadrer(couleur='k', couleur_fond=None, alpha=1)
label_temporaire
class wxgeometrie.geolib.textes.Texte_homothetie(texte, homothetie, **styles)

Une image d’un texte par homothetie.

Texte construit à partir d’un autre via une homothetie d’angle et de centre donné.

homothetie

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.textes.Texte_reflexion(texte, reflexion, **styles)

Une image d’un texte par reflexion.

Texte construit à partir d’un autre via une reflexion d’angle et de centre donné.

reflexion

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.textes.Texte_rotation(texte, rotation, **styles)

Une image d’un texte par rotation.

Texte construit à partir d’un autre via une rotation d’angle et de centre donné.

rotation

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.textes.Texte_transformation_generique(texte, transformation, **styles)

Une image d’un texte par transformation.

Classe mère de toutes les images de textes par transformation. (Usage interne).

style(*args, **kw)
texte

Un descripteur pour un argument d’un objet.

transformation

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.textes.Texte_translation(texte, translation, **styles)

Une image d’un texte par translation.

Texte construit à partir d’un autre via une translation d’angle et de centre donné.

texte

Un descripteur pour un argument d’un objet.

translation

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.transformations.Homothetie(centre=None, rapport=2, **styles)

Une homothétie.

Une homothétie définie par son centre et son rapport.

centre

Un descripteur pour un argument d’un objet.

rapport

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.transformations.Reflexion(droite=None, **styles)

Une symétrie axiale.

Une symétrie axiale (réflexion) définie par une droite.

droite

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.transformations.Rotation(centre=None, angle=None, unite=None, **styles)

Une rotation.

Une rotation définie par son centre, et un angle en radian (r), grad (g) ou degré (d). L’unité par défaut est le radian.

angle

Un descripteur pour un argument d’un objet.

centre

Un descripteur pour un argument d’un objet.

deg
degre
grad
rad
radian
class wxgeometrie.geolib.transformations.Symetrie_centrale(centre=None, **styles)

Une symétrie centrale.

Une symétrie centrale définie par un point.

centre

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.transformations.Transformation_generique(**styles)

Une transformation.

La classe mère de toutes les transformations (usage interne).

class wxgeometrie.geolib.transformations.Translation(vecteur=None, **styles)

Une translation.

Une translation définie par un vecteur.

vecteur

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.variables.Add(var1, var2, **styles)

La somme de deux variables.

var1

Un descripteur pour un argument d’un objet.

var2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.variables.Dpx(**styles)

Un pixel unité en abscisse.

class wxgeometrie.geolib.variables.Dpy(**styles)

Un pixel unité en ordonnée.

class wxgeometrie.geolib.variables.Mul(var1, var2, **styles)

Le produit de deux variables.

var1

Un descripteur pour un argument d’un objet.

var2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.variables.Pixel_unite(**styles)

Correspond à un pixel.

class wxgeometrie.geolib.variables.Rayon(cercle, **styles)

Le rayon d’un cercle.

>>> from wxgeometrie.geolib import Cercle, Rayon
>>> c = Cercle((0, 0), 1)
>>> float(c.rayon)
1.0
>>> r = Rayon(c)
>>> float(r)
1.0
>>> c.rayon = 2
>>> float(r)
2.0
cercle

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.variables.Variable(contenu=0, **styles)

Une variable libre.

Une variable numérique ; l’argument peut être un nombre, ou une expression sous forme de chaine de caractères. Exemple: Variable(17.5), Variable(“AB.longeur+1”). Dans ce dernier cas, il est nécessaire qu’une feuille de travail soit définie.

Note : ne pas définir directement l’attribut __contenu !

contenu
varier(debut=0, fin=1, pas=0.02, periode=0.03)
class wxgeometrie.geolib.variables.Variable_affichage(**styles)

La classe mère des paramètres d’affichage (xmin, xmax, …)

parametre = NotImplemented
class wxgeometrie.geolib.variables.Variable_generique(**styles)

Une variable générique.

Usage interne : la classe mère pour tous les types de variables.

class wxgeometrie.geolib.variables.XMaxVar(**styles)

Le maximum de la fenêtre en abscisse.

parametre = 'xmax'
class wxgeometrie.geolib.variables.XMinVar(**styles)

Le minimum de la fenêtre en abscisse.

parametre = 'xmin'
class wxgeometrie.geolib.variables.YMaxVar(**styles)

Le maximum de la fenêtre en ordonnée.

parametre = 'ymax'
class wxgeometrie.geolib.variables.YMinVar(**styles)

Le minimum de la fenêtre en ordonnée.

parametre = 'ymin'
class wxgeometrie.geolib.vecteurs.Extremite(representant, **styles)

L’extrémité d’un représentant de vecteur.abscisse

L’objet est créé automatiquement lors de la création du représentant.

representant

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.vecteurs.Representant(vecteur, origine=None, **styles)

Un représentant d’un vecteur.

Un représentant d’un vecteur, ayant pour origine un point donné.

on_register()

Lorsque le vecteur est enregistré dans la feuille, on enregistre également son extrémité, et son origine si elle ne l’est pas déjà.

origine

Un descripteur pour un argument d’un objet.

vecteur

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.vecteurs.Somme_vecteurs(vecteurs, coefficients=None, **styles)

Une somme de vecteurs.

Les arguments sont des couples coefficient, vecteur Exemple: Somme_vecteurs([u,v,A>B], [3,2,-5]).

coefficients

Un descripteur pour une liste d’arguments d’un objet.

coeffs

Un descripteur pour une liste d’arguments d’un objet.

vecteurs

Un descripteur pour une liste d’arguments d’un objet.

class wxgeometrie.geolib.vecteurs.Vecteur(point1=None, point2=None, **styles)

Un vecteur.

Un vecteur défini par deux points.

extremites
image_par(transformation)
point1

Un descripteur pour un argument d’un objet.

point2

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.vecteurs.Vecteur_generique(**styles)

Un vecteur générique.

Usage interne : la classe mère pour les différents vecteurs

abscisse
affixe
egal(y)
egale(y)
norme
ordonnee
x
y
z
class wxgeometrie.geolib.vecteurs.Vecteur_libre(x=None, y=None, **styles)

Un vecteur libre.

Un vecteur défini par ses coordonnées.

abscisse

Un descripteur pour un argument d’un objet.

ordonnee

Un descripteur pour un argument d’un objet.

x

Un descripteur pour un argument d’un objet.

y

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.vecteurs.Vecteur_unitaire(vecteur=None, **styles)

Un vecteur unitaire.

Un vecteur défini en normalisant un autre vecteur. Il aura donc même sens et même direction, mais sera de norme 1.

vecteur

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.widgets.Bouton(texte=' ', x=None, y=None, **styles)

Un bouton cliquable.

Un bouton avec texte. Typiquement, on lui associe une action lorsque l’on clique dessus, via la méthode onLeftClick.

abscisse

Un descripteur pour un argument d’un objet.

ordonnee

Un descripteur pour un argument d’un objet.

texte

Un descripteur pour un argument d’un objet.

x

Un descripteur pour un argument d’un objet.

y

Un descripteur pour un argument d’un objet.

class wxgeometrie.geolib.widgets.Champ(texte='', x=None, y=None, **styles)

Un champ de texte.

Un champ de texte éditable en double-cliquant dessus.

Le champ peut être encadré par du texte, via les mots-clefs prefixe (texte à gauche) et suffixe (texte à droite). On peut également lui associer un résultat attendu, via le mot-clef attendu:

>>> from wxgeometrie import Champ
>>> c = Champ('modifiez moi', 10, 5, prefixe="1+1=", attendu="2",
...            formatage='rien', suffixe=" (entrer le resultat)")
>>> c.style("attendu")
'2'
>>> c.texte = '?'
>>> print(c.label())
1+1=? (entrer le resultat)

Si un résultat est attendu, alors le texte rentré par l’utilisateur passera un test de validation. Si le résultat passe le test, un check vert est affiché à côté, sinon, un smiley :-( rouge est affiché.

Par défaut, pour être validé, il faut que le résultat soit exactement conforme au texte attendu:

>>> c.texte = "2.0"
>>> c.correct
False
>>> c.texte = "2"
>>> c.correct
True

Cependant, il est possible de définir un test de validation personnalisé:

>>> def test(reponse, attendu):
...     return float(reponse) == float(attendu)
>>> c.valider = test
>>> c.texte = "2.0"
>>> c.correct
True

On peut aussi associer une action à la validation:

>>> def action(**kw):
...     if kw['correct']:
...         if not kw['correct_old']:
...             # Ce n'était pas correct avant
...             print('Bravo !')
...         else:
...             # C'était déjà correct
...             print("Oui, c'est bon aussi !")
...     else:
...         print('Essaie encore...')
>>> c.evt_valider = action
>>> c.texte = "3"
Essaie encore...
>>> c.texte = "2"
Bravo !
>>> c.texte = "2.0"
Oui, c'est bon aussi !

Cet action sera effectuée lorsque le texte du champ est modifié, si celui-ci passe le test de validation.

Enfin, une liste des propositions peut être passée via le mot-clef choix:

>>> c = Champ('', 10, 5, choix=['oui', 'non', 'sans opinion'])
>>> c.style('choix')
['oui', 'non', 'sans opinion']
abscisse

Un descripteur pour un argument d’un objet.

correct = None
evt_valider = None
label(*args, **kw)
ordonnee

Un descripteur pour un argument d’un objet.

style(*args, **kw)
texte

Un descripteur pour un argument d’un objet.

valider = None
x

Un descripteur pour un argument d’un objet.

y

Un descripteur pour un argument d’un objet.

wxgeo.GUI

class wxgeometrie.GUI.barre_outils.BarreOutils(parent)
add(racc, *liste)

Ajoute des boutons multiples, sélectionnables.

racc est un raccourci. Ex: « Control+F1 », « Shift+F2 », « Meta+F3 », « Alt+F12 ». liste est une liste de tuples, ayant le format suivant: (titre, nom de l’image, aide, action) liste peut également contenir None, qui sert de séparateur.

add2(*args)

Ajoute des boutons simples, non sélectionnables.

args possède le format suivant: nom de l’image, aide, action

angle(event=False, **kw)
angle_oriente(event=False, **kw)
arc(event=False, **kw)
arc_oriente(event=False, **kw)
arc_points(event=False, **kw)
axe(event=False, **kw)
bissectrice(event=False, **kw)
canvas
carre(event=False, **kw)
cercle(event=False, **kw)
cercle_diametre(event=False, **kw)
cercle_points(event=False, **kw)
creer_boutons()
curseur(event=None)

Revenir en mode standard (flêche simple).

demicercle(event=False, **kw)
demidroite(event=False, **kw)
demiplan(event=False, **kw)
dialogue(titre, question, defaut='')

Certaines constructions ont besoin d’une valeur numérique (rotations, homothéties…) Cette boîte de dialogue permet à l’utilisateur de saisir cette valeur. Retourne “None” si l’utilisateur a annulé.

disque(event=False, **kw)
droite(event=False, **kw)
executer(instruction, editer='defaut', init=True)

Exécute une instruction dans la console. Si editer != None, le nom de l’objet est édité (par défaut, seulement les points, droites et textes), afin de permettre de le renommer dans la foulee. Si init = True, le cache des selections est initialise.

feuille_actuelle
gomme(event=False, **kw)
homothetie(event=False, **kw)
initialiser()
interagir(*args, **kw)

Marque le bouton n comme sélectionné (et initialise le cache des sélections).

intersection(event=False, **kw)
losange(event=False, **kw)
masque(event=False, **kw)
mediatrice(event=False, **kw)
milieu(event=False, **kw)
npoints(classe, n=2, nom_style='', **kw)

Création d’un objet de classe “classe” ayant “n” points comme arguments. Le nom de l’objet sera composé de “prefixe” + 1 numéro.

parallele(event=False, **kw)
parallelogramme(event=False, **kw)
perpendiculaire(event=False, **kw)
pinceau(event=False, **kw)
point(event=False, nom_style='points', editer='defaut', **kw)
polygone(event=False, **kw)
rafraichir()

Appelé par le parent pour rafraichir la barre d’outils.

rectangle(event=False, **kw)
reflexion(event=False, **kw)
representant(event=False, **kw)
rotation(event=False, **kw)
segment(event=False, **kw)
selectionner(event=False, **kw)

Sélectionner une zone.

style(type_objet)

Retourne le style d’objet défini éventuellement dans les paramètres du module.

symetrie(event=False, **kw)
tangente(event=False, **kw)
test(doublons_interdits=True, **kw)

On vérifie qu’il y ait encore une feuille, et que le cache ne contienne que des objets de la feuille (la feuille a pu changer, ou un objet être supprimé).

texte(event=False, **kw)
translation(event=False, **kw)
triangle(event=False, **kw)
triangle_equilateral(event=False, **kw)
triangle_isocele(event=False, **kw)
triangle_isocele_rectangle(event=False, **kw)
triangle_rectangle(event=False, **kw)
vecteur(event=False, **kw)
zoombox(event=False, **kw)

Mode zoom.

class wxgeometrie.GUI.barre_outils.MultiButton(parent, raccourci, selectionnable, *fonctionnalites)

Un bouton possédant plusieurs fonctionnalités, que l’utilisateur peut choisir avec un clic de la souris.

static img2icon(image)
select(selected=True, i=None)

(Dé)sélectionne le bouton.

Si i est différent de None, la i-ème fonctionnalité associée au bouton est activée.

L’icône est automatiquement mise à jour.

selected
update_display(as_selected=None)

Change l’icône du bouton, selon la fonction sélectionnée, et le fait que le bouton soit activé ou non.

Il est possible de forcer l’affichage du bouton comme s’il était sélectionné, en passant l’option as_selected=True. Cela sert pour le bouton sauvegarde par exemple.

update_menu()
class wxgeometrie.GUI.contact.Contact(parent)

Formulaire utilisé pour contacter l’auteur et rapporter les bogues.

rapporter()
sent
termine(success, msg)
class wxgeometrie.GUI.dialogues_geometrie.Dialogue(parent, titre='', size=None)
affiche()
ajoute(contenu, aide='')

Ajoute une ligne de contenu dans la boite de dialogue.

Format du contenu : (« texte statique »,(« nom de champ », taille), etc…) Exemple : (« entrez l’abscisse : »,(« absc »,10), »cm ») Pour un champ, un 3e argument peut-être indiqué pour donner le type d’objet, s’il s’agit d’un objet géométrique (ou None). Un 4e argument peut-etre saisi, pour donner le comportement en cas d’agrandissement, et un 5e, pour indiquer une valeur initiale du champ. Le champ créé sera accessible via self.champ(« abcs »).

L’argument type d’objet sert à faire des propositions à l’utilisateur lors d’un clic du milieu.

Le type d’objet peut-être compris dans une liste d’un seul élement, par exemple : [Point_generique] Cela signifie alors que le champ doit contenir une liste de points, et non un seul point.

A noter qu’un tuple, comme (Point_generique, Vecteur), par contre, correspond au comportement habituel de Python: l’objet est soit un Point_generique, soit un Vecteur

champ(etiquette)
commande()
finalise()
objet = None
parametres()
right_click(type, champ)

Retourne une fonction qui sera executée lors d’un clic droit sur le champ “champ”.

class wxgeometrie.GUI.dialogues_geometrie.DialogueAngle(parent)
objet

alias de wxgeometrie.geolib.angles.Angle

class wxgeometrie.GUI.dialogues_geometrie.DialogueAngleLibre(parent)
commande()
objet

alias de wxgeometrie.geolib.angles.Angle_libre

class wxgeometrie.GUI.dialogues_geometrie.DialogueAngleOriente(parent)
objet

alias de wxgeometrie.geolib.angles.Angle_oriente

class wxgeometrie.GUI.dialogues_geometrie.DialogueAngleVectoriel(parent)
objet

alias de wxgeometrie.geolib.angles.Angle_vectoriel

class wxgeometrie.GUI.dialogues_geometrie.DialogueArcCercle(parent)
objet

alias de wxgeometrie.geolib.cercles.Arc_cercle

class wxgeometrie.GUI.dialogues_geometrie.DialogueArcOriente(parent)
objet

alias de wxgeometrie.geolib.cercles.Arc_oriente

class wxgeometrie.GUI.dialogues_geometrie.DialogueArcPoints(parent)
objet

alias de wxgeometrie.geolib.cercles.Arc_points

class wxgeometrie.GUI.dialogues_geometrie.DialogueBarycentre(parent)
objet

alias de wxgeometrie.geolib.points.Barycentre

parametres()
class wxgeometrie.GUI.dialogues_geometrie.DialogueBissectrice(parent)
objet

alias de wxgeometrie.geolib.lignes.Bissectrice

class wxgeometrie.GUI.dialogues_geometrie.DialogueCentre(parent)
objet

alias de wxgeometrie.geolib.points.Centre

class wxgeometrie.GUI.dialogues_geometrie.DialogueCentreCercleCirconscrit(parent)
objet

alias de wxgeometrie.geolib.points.Centre_cercle_circonscrit

class wxgeometrie.GUI.dialogues_geometrie.DialogueCentreCercleInscrit(parent)
objet

alias de wxgeometrie.geolib.points.Centre_cercle_inscrit

class wxgeometrie.GUI.dialogues_geometrie.DialogueCentreGravite(parent)
objet

alias de wxgeometrie.geolib.points.Centre_gravite

class wxgeometrie.GUI.dialogues_geometrie.DialogueCercle(parent)
objet

alias de wxgeometrie.geolib.cercles.Cercle

class wxgeometrie.GUI.dialogues_geometrie.DialogueCercleDiametre(parent)
objet

alias de wxgeometrie.geolib.cercles.Cercle_diametre

class wxgeometrie.GUI.dialogues_geometrie.DialogueCerclePoints(parent)
objet

alias de wxgeometrie.geolib.cercles.Cercle_points

class wxgeometrie.GUI.dialogues_geometrie.DialogueCercleRayon(parent)
objet

alias de wxgeometrie.geolib.cercles.Cercle_rayon

class wxgeometrie.GUI.dialogues_geometrie.DialogueDemiCercle(parent)
objet

alias de wxgeometrie.geolib.cercles.Demicercle

class wxgeometrie.GUI.dialogues_geometrie.DialogueDemidroite(parent)
objet

alias de wxgeometrie.geolib.lignes.Demidroite

class wxgeometrie.GUI.dialogues_geometrie.DialogueDisque(parent)
objet

alias de wxgeometrie.geolib.cercles.Disque

class wxgeometrie.GUI.dialogues_geometrie.DialogueDroite(parent)
objet

alias de wxgeometrie.geolib.lignes.Droite

class wxgeometrie.GUI.dialogues_geometrie.DialogueFenetre(parent)
commande()
restaurer()
class wxgeometrie.GUI.dialogues_geometrie.DialogueGlisseurCercle(parent)
objet

alias de wxgeometrie.geolib.points.Glisseur_cercle

class wxgeometrie.GUI.dialogues_geometrie.DialogueGlisseurDroite(parent)
objet

alias de wxgeometrie.geolib.points.Glisseur_droite

class wxgeometrie.GUI.dialogues_geometrie.DialogueGlisseurSegment(parent)
objet

alias de wxgeometrie.geolib.points.Glisseur_segment

class wxgeometrie.GUI.dialogues_geometrie.DialogueHomothetie(parent)
objet

alias de wxgeometrie.geolib.transformations.Homothetie

class wxgeometrie.GUI.dialogues_geometrie.DialogueImage(parent)
commande()
class wxgeometrie.GUI.dialogues_geometrie.DialogueInterCercles(parent)
objet

alias de wxgeometrie.geolib.intersections.Intersection_cercles

class wxgeometrie.GUI.dialogues_geometrie.DialogueInterDroiteCercle(parent)
objet

alias de wxgeometrie.geolib.intersections.Intersection_droite_cercle

class wxgeometrie.GUI.dialogues_geometrie.DialogueInterDroites(parent)
objet

alias de wxgeometrie.geolib.intersections.Intersection_droites

class wxgeometrie.GUI.dialogues_geometrie.DialogueInterpolationLineaire(parent)
commande()
objet

alias de wxgeometrie.geolib.interpolations.Interpolation_lineaire

class wxgeometrie.GUI.dialogues_geometrie.DialogueInterpolationQuadratique(parent)
commande()
objet

alias de wxgeometrie.geolib.interpolations.Interpolation_quadratique

class wxgeometrie.GUI.dialogues_geometrie.DialogueMediatrice(parent)
objet

alias de wxgeometrie.geolib.lignes.Mediatrice

class wxgeometrie.GUI.dialogues_geometrie.DialogueMilieu(parent)
objet

alias de wxgeometrie.geolib.points.Milieu

class wxgeometrie.GUI.dialogues_geometrie.DialogueOrthocentre(parent)
objet

alias de wxgeometrie.geolib.points.Orthocentre

class wxgeometrie.GUI.dialogues_geometrie.DialogueParallele(parent)
objet

alias de wxgeometrie.geolib.lignes.Parallele

class wxgeometrie.GUI.dialogues_geometrie.DialogueParallelogramme(parent)
objet

alias de wxgeometrie.geolib.polygones.Parallelogramme

class wxgeometrie.GUI.dialogues_geometrie.DialoguePerpendiculaire(parent)
objet

alias de wxgeometrie.geolib.lignes.Perpendiculaire

class wxgeometrie.GUI.dialogues_geometrie.DialoguePoint(parent)
objet

alias de wxgeometrie.geolib.points.Point

class wxgeometrie.GUI.dialogues_geometrie.DialoguePointFinal(parent)
commande()
objet

alias de wxgeometrie.geolib.points.Point_final

class wxgeometrie.GUI.dialogues_geometrie.DialoguePolygone(parent)
commande()
objet

alias de wxgeometrie.geolib.polygones.Polygone

class wxgeometrie.GUI.dialogues_geometrie.DialoguePolygoneRegulier(parent)
objet

alias de wxgeometrie.geolib.polygones.Polygone_regulier

class wxgeometrie.GUI.dialogues_geometrie.DialoguePolygoneRegulierCentre(parent)
objet

alias de wxgeometrie.geolib.polygones.Polygone_regulier_centre

class wxgeometrie.GUI.dialogues_geometrie.DialogueReflexion(parent)
objet

alias de wxgeometrie.geolib.transformations.Reflexion

class wxgeometrie.GUI.dialogues_geometrie.DialogueRepresentant(parent)
objet

alias de wxgeometrie.geolib.vecteurs.Representant

class wxgeometrie.GUI.dialogues_geometrie.DialogueRotation(parent)
commande()
objet

alias de wxgeometrie.geolib.transformations.Rotation

class wxgeometrie.GUI.dialogues_geometrie.DialogueSegment(parent)
objet

alias de wxgeometrie.geolib.lignes.Segment

class wxgeometrie.GUI.dialogues_geometrie.DialogueSymetrieCentrale(parent)
objet

alias de wxgeometrie.geolib.transformations.Symetrie_centrale

class wxgeometrie.GUI.dialogues_geometrie.DialogueTangente(parent)
objet

alias de wxgeometrie.geolib.lignes.Tangente

class wxgeometrie.GUI.dialogues_geometrie.DialogueTexte(parent)
commande()
objet

alias de wxgeometrie.geolib.textes.Texte

class wxgeometrie.GUI.dialogues_geometrie.DialogueTranslation(parent)
objet

alias de wxgeometrie.geolib.transformations.Translation

class wxgeometrie.GUI.dialogues_geometrie.DialogueTriangle(parent)
objet

alias de wxgeometrie.geolib.polygones.Triangle

class wxgeometrie.GUI.dialogues_geometrie.DialogueVariable(parent)
objet

alias de wxgeometrie.geolib.variables.Variable

class wxgeometrie.GUI.dialogues_geometrie.DialogueVecteur(parent)
objet

alias de wxgeometrie.geolib.vecteurs.Vecteur

class wxgeometrie.GUI.dialogues_geometrie.DialogueVecteurLibre(parent)
objet

alias de wxgeometrie.geolib.vecteurs.Vecteur_libre

class wxgeometrie.GUI.dialogues_geometrie.EditerObjet(parent)
class wxgeometrie.GUI.dialogues_geometrie.SupprimerObjet(parent)
wxgeometrie.GUI.dialogues_geometrie.repr_str(chaine)

Force la chaîne a être représentée entourée de guillemets doubles (« ).

class wxgeometrie.GUI.inspecteur.EditeurPython(parent)
keyPressEvent(event)
class wxgeometrie.GUI.inspecteur.FenCode(parent, titre, contenu, fonction_modif)

Permet d’éditer du code Python.

En particulier, permet d’éditer le code de la feuille actuelle.

executer(event=None)
class wxgeometrie.GUI.menu_objet.MenuActionsObjet(canvas)
copier_style(critere='categorie')

Applique le style de l’objets à tous les objets de même catégorie.

Si critere=”sous-categorie”, le style est seulement appliqué aux objets de même sous-catégorie (ex. “vecteurs”), et non à la catégorie entière (ex. “lignes”).

copier_style_cotes()

Applique le style du polygone à ses côtés.

etiquette()
executer(commande)
masquer_nom()
mode_formatage()
proprietes()
redefinir()

Redéfinit l’objet (si possible).

Par exemple, on peut remplacer Droite(A, B) par Segment(A, B).

renommer()

Renomme l’objet, et met l’affichage de la légende en mode “Nom”.

select(obj)
class wxgeometrie.GUI.menu.Menu(menubar, titre, liste)

Remplace la classe QMenu.

actualiser()
class wxgeometrie.GUI.menu.MenuBar(panel=None, *contenu)

Remplace la classe QMenuBar pour créer une barre de menu propre à chaque module.

La méthode de base est ajouter(self, *menu), où menu est une liste.

Exemple 1 :

menu = [« Outils »,

[« Options », « Parametres du programme », « Ctrl+O », fonction1], [« Memoriser le resultat », « Copie le resultat du calcul dans le presse-papier », None, fonction2], None, [« Autres »,

[« Rubrique 1 », None, « Alt+Ctrl+R », fonction3], [« Rubrique 2 », « Rubrique non active pour l’instant », None, None]]]

Exemple 2 :

["Infos", ["Afficher les infos", "Affichage des infos en temps reel", "Ctrl+I", fonction1, fonction2]]

La presence de deux fonctions (eventuellement identiques) indique qu’il s’agit d’un menu « cochable ». L’etat (coché ou non coché) est déterminé par la valeur renvoyée par la fonction “fonction2”.

Note: Pour un menu moins standard, on peut toujours utiliser directement QMenuBar.

ajouter(*contenu)
class wxgeometrie.GUI.menu.RSSMenu(titre='', liste=None, fonction=None, aide='')

Menu dynamique.

update(liste=None, fonction=None, aide=None)
# .. automodule:: wxgeometrie.GUI.onglets
members:
undoc-members:
class wxgeometrie.GUI.panel.Panel_API_graphique(parent, module, BarreOutils=<class 'wxgeometrie.GUI.barre_outils.BarreOutils'>)

Pour les modules ayant besoin de TOUTE l’API de WxGéométrie (canvas, historique, gestion des commandes, etc…) et pas seulement des bibliothèques, mieux vaut utiliser cette classe. Cela concerne essentiellement les modules qui ont besoin de tracer des objets géométriques.

action_effectuee(log, signature=None)
activer()

Actions à effectuer lorsque l’onglet du module est sélectionné.

À surclasser éventuellement.

affiche(event=None)
afficher_barre_outils(afficher=None)

Afficher ou non la barre d’outils.

afficher_console_geolib(afficher=None)

Afficher ou non la ligne de commande de la feuille.

annuler(event=None)
changer_titre(texte=None)
charger_feuille(feuille)
creer_feuille(nom=None)
desactiver()

Actions à effectuer lorsque l’onglet du module est désélectionné.

À surclasser éventuellement.

executer_macro(**kw)
exporter(path)
fermer_feuille(feuille=None)
fermer_feuilles()

Ferme toute les feuilles.

feuille_actuelle
finaliser(contenu=None)
modifie
nom_sauvegarde

Nom de sauvegarde gardé en mémoire.

ouvrir(fichier)
rafraichir_titre()

Actualise le titre de la fenêtre, et la liste des feuilles ouvertes dans le menu.

reinitialiser()

Réinitialise le module (ferme les travaux en cours, etc.).

À surclasser dans la majorité des cas.

retablir(event=None)
sauvegarder(nom_fichier='', feuille=None)

Sauvegarde la feuille feuille à l’emplacement nom_fichier.

Par défaut, feuille et la feuille courante, et le nom de fichier est celui utilisé précédemment pour sauver la feuille (ou « sauvegarde.geo » si la feuille n’a encore jamais été sauvée).

NB: si nom_fichier vaut None, aucune sauvegarde n’a lieu sur le disque, mais un objet FichierGEO correspondant à la sauvegarde est retourné à la place.

sauver_preferences(lieu=None)
update()

Fait les actualisations nécessaires quand la feuille courante change.

class wxgeometrie.GUI.panel.Panel_simple(parent, module, menu=True)

Remplace la classe la classe QWidget pour les différents modules. Pour les modules ayant besoin des fonctions graphiques evoluées de WxGéométrie, mieux vaut utiliser la classe Panel_API_graphique, plus evoluée que celle-ci.

action_effectuee(log, signature=None)
activer()

Actions à effectuer lorsque l’onglet du module est sélectionné.

À surclasser éventuellement.

changer_titre(texte='')
desactiver()

Actions à effectuer lorsque l’onglet du module est désélectionné.

À surclasser éventuellement.

feuille_actuelle = None
message(texte='')
modifie = False
nom_sauvegarde

Nom de sauvegarde gardé en mémoire.

ouvrir(fichier)

Ouvre un un fichier .geo.

“fichier” est soit l’adresse d’un fichier .geo, soit une instance de FichierGEO.

param(parametre, valeur=<wxgeometrie.pylib.fonctions.NoArgument object>, defaut=False)

Renvoie la valeur du paramètre parametre.

Recherche la valeur d’un paramètre d’abord dans les paramètres du module _(paramètres locaux), puis dans ceux de wxgéométrie. Si defaut vaut True, la valeur par défaut du paramètre est renvoyée.

reinitialiser()

Réinitialise le module (ferme les travaux en cours, etc.).

À surclasser.

sauvegarder(nom_fichier='', compressed=None, **kw)
sauver_preferences(lieu=None)
static vers_presse_papier(texte)

Copie le texte dans le presse-papier.

Retourne True si la copie a réussi, False sinon.

class wxgeometrie.GUI.qtcanvas.MiniEditeur(parent)

Le mini éditeur de texte permet de taper du texte directement dans le canevas, sans utiliser une boîte de dialogue. Il est utilisé lorsqu’on crée un texte avec la souris, ou lorsqu’on crée un objet géométrique (point, cercle…) qu’on peut ainsi aussitôt nommer.

cancel()
close()

Ferme l’éditeur. Ne renvoie pas d’erreur s’il est déjà fermé.

display()

Affiche le texte en train d’être écrit.

init(objet, mode=0)

Edition d’un nouvel objet. mode = 0: édition du nom de l’objet mode = 1: édition de l’étiquette de l’objet

key(key, txt, modifiers)
ok()
class wxgeometrie.GUI.qtcanvas.QtCanvas(parent, fixe=False)
Copy_to_Clipboard(**kw)
activer_affichage()

Activer l’affichage.

Cette méthode est appelée lorsque l’onglet devient actif.

as_QImage(**kw)
coordonnees(event, dx=0, dy=0)

Renvoie les coordonnées correspondant à l’évènement, converties en coordonnées de la feuille. Si [Maj] est enfoncée, les coordonnées sont arrondies à la graduation la plus proche. dx et dy correspondent au décalage entre les coordonnées de l’objet, et le point où on l’a saisit. (Par exemple, un texte n’est pas forcément saisi au niveau de son point d’ancrage).

deplacable(obj)
desactiver_affichage()

Désactiver l’affichage.

Cette méthode est appelée lorsque l’onglet devient inactif. Cela évite de solliciter le processeur pour rien.

detecter(position=None)

Détecte les objets à proximité de la position indiquée. Typiquement, on utilise self.detecter(lieu(event)).

dimensions
editer(mode=0)
exporter(*args, **kw)
feuille_actuelle
infos()
interagir(fonction, aide=None, fonction_bis=None)

Permet l’interaction du canevas avec un module externe.

À chaque clic de souris, la fonction indiquée est appelée, avec un certains nombre de paramètres comme arguments : objet(s) à proximité, position en coordonnées et en pixels…

Une aide est éventuellement affichée dans la barre d’état de la fenêtre principale.

fonction_bis est éventuellement utilisée lors de chaque déplacement de la souris. Elle reçoit en argument la position en pixels uniquement (pour ne pas alourdir le traitement).

Exemple de récupération des arguments : si un module appelle self.canvas.interagir(ma_fonction, u"Cliquez n'importe où.", ma_2eme_fonction), le module doit définir :

def ma_fonction(self, **kw):
    pixel = kw["pixel"]
    position = kw["position"]
    objet_selectionne = kw["selection"]
    autres_objets_a_proximite = kw["autres"]
    print u"clic!"

def ma_2eme_fonction(self, **kw):
    pixel = kw["pixel"]
    print u"ça bouge !"
interrompre_action_en_cours()
keyPressEvent(event)
keyReleaseEvent(event)
leaveEvent(event)
message(txt, lieu=0, temporaire=True)

Affiche un message dans la barre d’état.

Par défaut, le message est temporaire, c’est-à-dire qu’il sera effacé dès que l’utilisateur bougera la souris, pour laisser la place au message « permanent », qui indique généralement le mode actif.

Cette méthode retourne le message « permanent » actuel.

mouseDoubleClickEvent(event)
mouseMoveEvent(event)
mousePressEvent(event)
mouseReleaseEvent(event)
onLeftDown(event)
onLeftUp(event)
onRightDown(event)
onRightUp(event)
onSelect()
param(*args, **kw)
pointable(obj)
regler_repere(event=None)
resizeEvent(event)
signal(event=None)
test_mode(event)

Retourne le mode (“defaut”, “select” ou “zoom”).

La méthode .test_mode() ne tient pas seulement compte de self.mode, mais aussi des touches pressées (CTRL, ALT…), et de self.fixe.

wheelEvent(event)

Gestion du zoom par la roulette de la souris.

class wxgeometrie.GUI.qtlib.BusyCursor
class wxgeometrie.GUI.qtlib.ColorSelecter(parent, color=None)

A bouton used to select a color.

colorSelected
onClick()
setColor(color)
class wxgeometrie.GUI.qtlib.GenericThread(function, *args, **kwargs)
run()
class wxgeometrie.GUI.qtlib.MultipleChoiceDialog(parent, title, text, items)
selectedItems()
class wxgeometrie.GUI.qtlib.MyMiniFrame(parent, titre='')
class wxgeometrie.GUI.qtlib.PopUpMenu(title, parent, icon=None)

Un menu avec un titre visible.

setTitle(title)
wxgeometrie.GUI.qtlib.alt_down(event)
wxgeometrie.GUI.qtlib.ctrl_down(event)
wxgeometrie.GUI.qtlib.left_down(event)
wxgeometrie.GUI.qtlib.lieu(event_or_widget)
wxgeometrie.GUI.qtlib.meta_down(event)
wxgeometrie.GUI.qtlib.png(nom)

Charge l’image <nom>.png depuis le repertoire “images/”.

L’image doit être au format png, et son nom doit indiqué sans l’extension “.png”.

wxgeometrie.GUI.qtlib.png_pth(nom)

Adresse complète de l’image nom.png du repertoire “images/”.

Le nom doit être indiqué sans l’extension “.png”.

wxgeometrie.GUI.qtlib.right_down(event)
wxgeometrie.GUI.qtlib.shift_down(event)

wxgeo.initialisation

wxgeo.mathlib

wxgeometrie.mathlib.custom_functions.aide(fonction)

Retourne (si possible) de l’aide sur la fonction saisie.

wxgeometrie.mathlib.custom_functions.arrondir(valeur, chiffres=0)
wxgeometrie.mathlib.custom_functions.auto_collect(expression)

Factorise une expression en utilisant sympy.collect, sans préciser manuellement ce par quoi factoriser.

wxgeometrie.mathlib.custom_functions.bin(n)

Conversion en binaire.

wxgeometrie.mathlib.custom_functions.binomial(a, b, n, p)

Retourne P(a <= X <= b), où X suit la loi binomiale B(n, p).

..note:: Taper binomial(a, a, n, p) pour calculer P(X = a).

wxgeometrie.mathlib.custom_functions.canonique(polynome)

Met un polynôme du second degré sous forme canonique.

wxgeometrie.mathlib.custom_functions.cbrt(x)

Racine cubique de x.

wxgeometrie.mathlib.custom_functions.confiance(frequence, taille=1000, seuil=None)

Intervalle de confiance au seuil de 95%.

Retourne l’intervalle de confiance correspondant à un échantillon de taille taille, lorsque la fréquence observée sur l’échantillon est frequence.

Par défaut, si seuil n’est pas fixé, l’approximation utilisée est [f - 1/sqrt(n), f + 1/sqrt(n)], pour un seuil environ égal à 95%.

wxgeometrie.mathlib.custom_functions.covariance(serie1, serie2, coeffs=None)

Retourne la covariance des deux séries.

wxgeometrie.mathlib.custom_functions.deg(x)

Conversion radians -> degrés.

wxgeometrie.mathlib.custom_functions.derivee(f)
wxgeometrie.mathlib.custom_functions.discriminant(polynome)

Calcule le discriminant d’un polynôme du second degré.

wxgeometrie.mathlib.custom_functions.ecart_type(serie, coeffs=None)

Retourne l’écart-type de la série des (xi, fi).

wxgeometrie.mathlib.custom_functions.floats2rationals(expr)

Convertit tous les flottants d’une expression sympy en rationnels.

Si l’expression est de type list ou tuple, la fonction est appelée récursivement. Sinon, si elle n’est pas de type sympy, l’expression est renvoyée telle qu’elle.

wxgeometrie.mathlib.custom_functions.fluctu(probabilite, taille=1000, seuil=None)

Intervalle de fluctuation.

Retourne l’intervalle de fluctuation correspondant à un échantillon de taille taille, lorsque la probabilité est probabilite.

Par défaut, lorsque le seuil n’est pas fixé, l’approximation [p - 1.96*sqrt(p(1-p)/n), p + 1.96*sqrt(p(1-p)/n)] est utilisée, pour un seuil environ égal à 95%.

wxgeometrie.mathlib.custom_functions.frac(valeur, n=20, epsilon=1e-15)

Donne une fraction approximativement égale à la valeur.

wxgeometrie.mathlib.custom_functions.gcd(a, b)

pgcd de a et de b

wxgeometrie.mathlib.custom_functions.inv_normal(p)

Lower tail quantile for standard normal distribution function.

This function returns an approximation of the inverse cumulative standard normal distribution function. I.e., given P, it returns an approximation to the X satisfying P = Pr{Z <= X} where Z is a random variable from the standard normal distribution.

The algorithm uses a minimax approximation by rational functions and the result has a relative error whose absolute value is less than 1.15e-9.

Author: Peter John Acklam Time-stamp: 2000-07-19 18:26:14 E-mail: pjacklam@online.no WWW URL: http://home.online.no/~pjacklam

wxgeometrie.mathlib.custom_functions.jhms(s)

Convertit un temps en secondes en jours-heures-minutes-secondes.

wxgeometrie.mathlib.custom_functions.lcm(a, b)

ppcm de a et de b

wxgeometrie.mathlib.custom_functions.linreg(serie1, serie2, coeffs=None)

Droite de régression par la méthode des moindres carrés.

Retourne les coefficients a et b de l’équation y=ax+b

de la droite de régression par la méthode des moindres carrés.

>>> from wxgeometrie.mathlib.custom_functions import linreg
>>> linreg((85.6,84.5,81,80.2,72.8,71.2,73,48.1),(78.7,77.6,75.2,71.1,67.7,66.3,59.1,46.8))
(0.849191825268073, 4.50524942626518)
wxgeometrie.mathlib.custom_functions.moyenne(serie, coeffs=None)

Calcule l’espérance de la série des (xi, fi).

wxgeometrie.mathlib.custom_functions.n_premiers(n=100, maximum=50000)

Donne la liste des n premiers nombres premiers.

wxgeometrie.mathlib.custom_functions.normal(a, b, mu=0, sigma=1)

Retourne P(a < X < b), où X suit la loi normale N(mu, sigma²).

wxgeometrie.mathlib.custom_functions.pgcd(*termes)

Le plus grand dénominateur commun à un nombre quelconque d’entiers.

wxgeometrie.mathlib.custom_functions.ppcm(*termes)

Le plus petit multiple commun à un nombre quelconque d’entiers.

wxgeometrie.mathlib.custom_functions.proba(relation)
wxgeometrie.mathlib.custom_functions.prod(facteurs)
wxgeometrie.mathlib.custom_functions.pstfunc(chaine)

Convertit une chaine représentant une fonction pst-trick en une fonction

wxgeometrie.mathlib.custom_functions.rationals2floats(expr, precision=None)

Convertit tous les rationnels d’une expression sympy en flottants.

On peut spécifier via precision le nombre de chiffres significatifs.

Si l’expression est de type list ou tuple, la fonction est appelée récursivement. Sinon, si elle n’est pas de type sympy, l’expression est renvoyée telle qu’elle.

wxgeometrie.mathlib.custom_functions.root(x, n)

Racine nième de x.

N’est définie pour x négatif que si n est pair.

wxgeometrie.mathlib.custom_functions.round_afz(val, ndigits=0)

Round using round-away-from-zero strategy for halfway cases.

Python 3+ implements round-half-even, and Python 2.7 has a random behaviour from end user point of view (in fact, result depends on internal representation in floating point arithmetic).

wxgeometrie.mathlib.custom_functions.va(loi, *parametres)
wxgeometrie.mathlib.custom_functions.variance(serie, coeffs=None)

Calcule la variance de la serie des (xi, fi)

class wxgeometrie.mathlib.custom_objects.CallContext
add_prec(val)
calls = {140381925488448: 0}
get_prec()
is_first_call()
prec = {140381925488448: -inf}
class wxgeometrie.mathlib.custom_objects.Decim

Fonctionne comme un rationnel sympy, mais s’affiche comme un décimal.

Ceci permet, dans la calculatrice, de faire des calculs avec des décimaux, tout en ayant en interne des résultats exacts, et donc d’éviter les cumuls d’erreurs d’arrondis.

default_assumptions = {'algebraic': True, 'commutative': True, 'complex': True, 'composite': False, 'even': False, 'hermitian': True, 'imaginary': False, 'integer': False, 'irrational': False, 'noninteger': True, 'nonzero': True, 'odd': False, 'prime': False, 'rational': True, 'real': True, 'transcendental': False, 'zero': False}
is_algebraic = True
is_commutative = True
is_complex = True
is_composite = False
is_even = False
is_hermitian = True
is_imaginary = False
is_integer = False
is_irrational = False
is_noninteger = True
is_nonzero = True
is_odd = False
is_prime = False
is_rational = True
is_real = True
is_transcendental = False
is_zero = False
p
prec
q
to_Rational()
class wxgeometrie.mathlib.custom_objects.Fonction(variables, expression)

Une fonction de une ou plusieurs variables.

class wxgeometrie.mathlib.custom_objects.MesureDegres(val)

Usage interne : destiné à être utilisé avec deg.

class wxgeometrie.mathlib.custom_objects.ProduitEntiers

Usage interne : destiné à être utilisé avec sympy.factorint.

class wxgeometrie.mathlib.custom_objects.Temps(secondes=0, **kw)
jhms()
wxgeometrie.mathlib.custom_objects.convert2decim(expr, prec=None)
class wxgeometrie.mathlib.graphes.Graph(dictionary=(), oriented=False, labels=None)

A graph representation.

Graph are stored as a dictionary: >>> from wxgeometrie.mathlib.graphes import Graph >>> g = Graph({“A”: {“B”:[1],”C”:[2],”D”:[3]}, “B”: {“A”:[4],”C”:[2]}, “C”:{}, “D”:{}}, oriented=True)

For convenience, they may be entered as a string: >>> h = Graph(« A>(B:1,C:2,D:3), B>(A:4,C:2), C, D », oriented=True) >>> g == h True

If the graph is not oriented (default), the graph must be symetric: >>> k = Graph(« A>(B:1,C:2,D:3), B>(A:4,C:2), C>(A:2,B:2), D>(A:3) ») >>> k.symetric True

Graph nodes may have corresponding labels. A dict should be provided for this. >>> k = Graph(« A>(B:1,C:2,D:3), B>(A:4,C:2), C>(A:2,B:2), D>(A:3) »,

labels = {« A »: « Bus stop », « B »: « Office », « C »: « Bus stop », « D »: « Sweet home »)

Labels are used then in some methods to display meaningful text.

adjacents(node1, node2)
coloring(*first_nodes)

Graph colorization using Welsh & Powell algorithm.

By default, nodes are sorted according to their degrees, but you can also choose manually the first nodes to be visited.

connected
degree(node)
degrees
eulerian
eulerian_trail(walk=None)
latex_Dijkstra(start, end, nodes=None)
latex_WelshPowell(*first_nodes)
matrix
matrix2(default=0)
nodes

D.keys() -> a set-like object providing a view on D’s keys

order
shortest_path(start, end)

Implementation of Dijkstra-Moore algorithm.

symetric
to_dict
exception wxgeometrie.mathlib.graphes.GraphError
wxgeometrie.mathlib.graphes.colors()
wxgeometrie.mathlib.internal_functions.count_syms(expression, symbole)

Compte le nombre d’occurence de la variable dans l’expression.

wxgeometrie.mathlib.internal_functions.extract_var(expression)

Retourne la variable de l’expression (renvoie un avertissement s’il y en a plusieurs, et “x” par défaut s’il n’y en a pas).

wxgeometrie.mathlib.internal_functions.is_float(val)
wxgeometrie.mathlib.internal_functions.is_neg(expr)
wxgeometrie.mathlib.internal_functions.is_pos(expr)
wxgeometrie.mathlib.internal_functions.is_var(expression, variable)
wxgeometrie.mathlib.internal_functions.poly_factor(polynome, variable, corps=None, approchee=None)

Factorise un polynome à une variable.

Le corps peut être R ou C. Par défaut, le corps de factorisation est celui des coefficients.

wxgeometrie.mathlib.internal_functions.syms(expression)

Retourne la liste des symboles utilisés par l’expression.

class wxgeometrie.mathlib.internal_objects.ObjetMathematique

Classe mère de la plupart des objets mathématiques.

class wxgeometrie.mathlib.internal_objects.Reel

Classe mère pour les objets mathématiques supportant les fonctions usuelles. Permet de leur appliquer les opérations mathématiques de pylab.

abs(*args)
absolute(*args)
add(*args)
arccos(*args)
arccosh(*args)
arcsin(*args)
arcsinh(*args)
arctan(*args)
arctan2(*args)
arctanh(*args)
bitwise_and(*args)
bitwise_not(*args)
bitwise_or(*args)
bitwise_xor(*args)
cbrt(*args)
ceil(*args)
conj(*args)
conjugate(*args)
copysign(*args)
cos(*args)
cosh(*args)
deg2rad(*args)
degrees(*args)
divide(*args)
divmod(*args)
equal(*args)
exp(*args)
exp2(*args)
expm1(*args)
fabs(*args)
float_power(*args)
floor(*args)
floor_divide(*args)
fmax(*args)
fmin(*args)
fmod(*args)
frexp(*args)
greater(*args)
greater_equal(*args)
heaviside(*args)
hypot(*args)
invert(*args)
isfinite(*args)
isinf(*args)
isnan(*args)
isnat(*args)
ldexp(*args)
left_shift(*args)
less(*args)
less_equal(*args)
log(*args)
log10(*args)
log1p(*args)
log2(*args)
logaddexp(*args)
logaddexp2(*args)
logical_and(*args)
logical_not(*args)
logical_or(*args)
logical_xor(*args)
maximum(*args)
minimum(*args)
mod(*args)
modf(*args)
multiply(*args)
negative(*args)
nextafter(*args)
not_equal(*args)
positive(*args)
power(*args)
rad2deg(*args)
radians(*args)
reciprocal(*args)
remainder(*args)
right_shift(*args)
rint(*args)
sign(*args)
signbit(*args)
sin(*args)
sinh(*args)
spacing(*args)
sqrt(*args)
square(*args)
subtract(*args)
tan(*args)
tanh(*args)
true_divide(*args)
trunc(*args)
class wxgeometrie.mathlib.intervalles.Ensemble
class wxgeometrie.mathlib.intervalles.Intervalle

Un intervalle réel non vide. Les opération sur les intervalles sont : - l’union : symbole « A+B » - l’intersection : symbole « A*B » - la différence : symbole « A-B » - le complémentaire : symbole -A

inf_inclus
intervalles
singleton
sup_inclus
class wxgeometrie.mathlib.intervalles.Union

Une union finie d’intervalles réels. Les valeurs numériques isolées sont converties en singletons. Lors de l’initialisation, elle est reecrite sous forme d’union disjointe et ordonnée.

Les opération sur les unions d’intervalles sont : - l’union : symbole « A+B » ou « A|B” - l’intersection : symbole « A*B » ou « A&B » - la différence : symbole « A-B » - le complémentaire : symbole -A

Note: l’inclusion et l’appartenance sont notées de manière identique: « y in A » « A in B ».

Note: pour des raisons pratiques, l’ensemble vide est considéré comme un intervalle (sic).

adherence

L’adhérence de l’ensemble (ie. le plus petit ensemble fermé qui le contienne).

asarray(_min, _max, pas)

Génère une liste d’objets “array”, correspondant à chaque intervalle.

On se limite à des valeurs comprises entre “_min” et “_max”, avec le pas “pas”.

evalf(n=15, round_=None, **options)

Convertit les bornes de chaque intervalle en float.

extremites(_min, _max)

Retourne les extrémités de chaque intervalle.

Chaque extrémité est donnée sous la forme de couples (_float, _str), où _str peut prendre les valeurs « . », « ) », « ( » ou « o ». Exemple : >>> from wxgeometrie.mathlib.intervalles import conversion_chaine_ensemble >>> E = conversion_chaine_ensemble(« ]-oo;3[U]3;4]U]5;+oo[« ) >>> E.extremites(0, 10) [(3, “o”), (4, “.”), (5, “)”)]

simplifier()
vide
wxgeometrie.mathlib.intervalles.conversion_chaine_ensemble(chaine, utiliser_sympy=False)
wxgeometrie.mathlib.intervalles.formatage_ensemble(chaine, preformatage=True, utiliser_sympy=False)

Les symboles à utiliser sont “U” pour l’union, “^” pour l’intersection, “-“ ou “” pour la soustraction. R, R+, R*+, R-, R*- sont aussi acceptés.

wxgeometrie.mathlib.intervalles.preformatage_ensemble(chaine)

Formatage léger (qui reste humainement lisible).

wxgeometrie.mathlib.intervalles.preformatage_geolib_ensemble(chaine)

Cette fonction est destinée à un usage très spécifique dans geolib.

Elle accepte une syntaxe beaucoup plus souple que la précédente, et indique si les extrémités des intervalles doivent être affichés ou non. Par exemple: ]1;2] -> afficher les extrémités de la courbe en 1 (arc) et en 2 (point). 1;2] -> afficher l’extrémité en 2 (point), mais pas en 1. ]1;2 -> afficher l’extrémité en 1 (arc), mais pas en 2.

wxgeometrie.mathlib.parsers.convertir_en_latex(chaine, mode='$')

Convertit une chaine représentant un calcul en Python, en du code LaTeX.

modes actuels: “$”, None

L’intérêt de ne pas passer par sympy, c’est que le code n’a pas besoin d’être évalué. Si le code était évalué par sympy, cela pourrait modifier l’ordre des termes (par exemple, transformer 2-x en -x+2).

wxgeometrie.mathlib.parsers.extraire_chaines(chaine)

Extrait les chaînes de caractères trouvées dans chaine.

Chaque chaîne interne est remplacée par <@> (et le symbole @ lui-même est remplacé par @@). La fonction renvoie la chaîne ainsi modifiée, et une liste des chaînes internes extraites.

Exemple:

>>> from wxgeometrie.mathlib.parsers import extraire_chaines as extraire
>>> chaine = '''Voici une chaine: 'Bonjour ' et une autre: "l'ami !"'''
>>> chaine, sous_chaines = extraire(chaine)
>>> chaine

“Voici une chaine: <@> et une autre: <@>” >>> sous_chaines [« “Bonjour “ », “« l’ami ! »”]

wxgeometrie.mathlib.parsers.injecter_chaines(chaine, sous_chaines)
wxgeometrie.mathlib.parsers.latex2mathtext(chaine)

Convertit la chaîne pour qu’elle puisse être affichée par mathtext.

Matplotlib offre 2 possibilités pour l’affichage de chaînes LaTeX :

  • soit utiliser une installation LaTeX existante,
  • soit utiliser son propre moteur de rendu, mathtext.

Le rendu de matplotlib.mathtext est loin d’avoir la qualité du vrai LaTeX, mais il ne nécessite pas d’avoir LaTeX installé, il est bien plus rapide, et il permet l’export au format vectoriel (matplotlib utilise dvi2png sinon).

C’est donc le format utilisé par défaut.

wxgeometrie.mathlib.parsers.mathtext_parser(txt)
wxgeometrie.mathlib.parsers.simplifier_ecriture(formule)
wxgeometrie.mathlib.parsers.tex_dollars(txt)

Rajoute des $ si l’expression LaTeX ainsi obtenue est correcte.

wxgeometrie.mathlib.parsers.traduire_formule(formule='', fonctions=(), OOo=True, LaTeX=True, simpify=False, verbose=None, mots_cles=('False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'))

tools

tools.search.gs(string='', case=True, include_comments=False, comment_marker='#', extensions=('.py', '.pyw'), maximum=100, codec='utf8', stats=False, replace_with=None, color=None, edit_with=None, edit_result=None, skip_paths=())

Parcourt le répertoire courant et les sous-répertoire, à la recherche des fichiers dont l’extension est comprise dans “extensions”, mais passe les répertoires et les fichiers dont le nom commence par un préfixe de “exclude_prefixe”, ou finit par un suffixe de “exclude_suffixe”. Pour chaque fichier trouvé, renvoie toutes les lignes où “string” se trouve. (Par défaut, la casse est prise en compte, sinon, il suffit de modifier la valeur de “case”.) Le nombre maximal de lignes renvoyées est fixé par “maximum”, afin d’éviter de saturer le système. Si ce nombre est dépassé (ie. toutes les occurences de “string” ne sont pas affichées), la fonction renvoie False, sinon, True.