# 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)

    A property batch setter. Pass kwargs to set properties.

class `wxgeometrie.API.moteur_graphique.``ArcDeCercle`(canvas, **kw)
  `set`(**kw)

    A property batch setter. Pass kwargs to set properties.

  `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)

    A property batch setter. Pass kwargs to set properties.

  `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)

    A property batch setter. Pass kwargs to set properties.

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)

    A property batch setter. Pass kwargs to set properties.

  `set_alpha`(alpha)

    Set the alpha tranparencies of the collection. alpha must be a float or None.

    alpha : float or None

  `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.4'}
  `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`

    À 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…

  `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`

    Extrémités de l’arc.

  `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`

    À 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…

  `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`

    Extrémités de l’arc.

  `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`

    À 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…

  `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`

    À 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…

  `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)

    Return the value for key if key is in the dictionary, else default.

  `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)

    Return the value for key if key is in the dictionary, else default.

  `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 renvoyé: | 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>, 'pente_minimale': <function Interpolation_polynomiale_par_morceaux._strategie_pente_minimale>, 'pente_moyenne': <function Interpolation_polynomiale_par_morceaux._strategie_pente_moyenne>}
  `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`()

    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).

  `nom`
  `nom_latex`
  `parent`

    Un descripteur pour un argument d’un objet.

  `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 renvoyé: | string

  `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.

`wxgeometrie.geolib.labels.``sign`()

  Return a float with the magnitude (absolute value) of x but the sign of y.

  On platforms that support signed zeros, copysign(1.0, -0.0) returns -1.0.

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`

    À 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…

  `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)

    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`.

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

  Un segment.

  Un segment défini par deux points

  `extremites`
  `image_par`(transformation)
  `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…

  `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: | courbe (Interpolation_polynomiale_par_morceaux) – la courbe sur laquelle va se placer la tangente P (Glisseur_courbe) – Point de type glisseur sur la courbe.

  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.

`wxgeometrie.geolib.lignes.``sign`()

  Return a float with the magnitude (absolute value) of x but the sign of y.

  On platforms that support signed zeros, copysign(1.0, -0.0) returns -1.0.

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 renvoyé: | 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`

    À 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…

  `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)

    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`.

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`()

    Supprime l’objet de la feuille.

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`()

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

  `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`

    À 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…

  `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)

    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`.

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.``sign`()

  Return a float with the magnitude (absolute value) of x but the sign of y.

  On platforms that support signed zeros, copysign(1.0, -0.0) returns -1.0.

`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)

    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`.

  `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)

    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.

  `ordonnee`

    Un descripteur pour un argument d’un objet.

  `style`(*args, **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.

  `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`(self, QKeyEvent)

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`(self)

    update(self, QRect) update(self, QRegion) update(self, int, int, int, int)

# .. 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`

    bool(x) -> bool

    Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.

  `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.

  `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)

    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.

  `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`(self, QKeyEvent)
  `keyReleaseEvent`(self, QKeyEvent)
  `leaveEvent`(self, QEvent)
  `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`(self, QMouseEvent)
  `mouseMoveEvent`(self, QMouseEvent)
  `mousePressEvent`(self, QMouseEvent)
  `mouseReleaseEvent`(self, QMouseEvent)
  `onLeftDown`(event)
  `onLeftUp`(event)
  `onRightDown`(event)
  `onRightUp`(event)
  `onSelect`()
  `param`(*args, **kw)
  `pointable`(obj)
  `regler_repere`(event=None)
  `resizeEvent`(self, QResizeEvent)
  `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`(self)

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`(self, str)

`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` = {139748663547712: 0}
  `get_prec`()
  `is_first_call`()
  `prec` = {139748663547712: -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)
  `gcd`(*args)
  `greater`(*args)
  `greater_equal`(*args)
  `heaviside`(*args)
  `hypot`(*args)
  `invert`(*args)
  `isfinite`(*args)
  `isinf`(*args)
  `isnan`(*args)
  `isnat`(*args)
  `lcm`(*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)
  `matmul`(*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', 'async', 'await', '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.