Fonction | Action |
makeGPanel() | Crée une fenêtre de graphiques GPanel avec un système de coordonnées où x et y varient entre 0 et 1. Le curseur graphique est placé sur l’origine (0, 0) au coin inférieur gauche de la fenêtre |
makeGPanel(xmin, xmax, ymin, ymax) | Crée une fenêtre GPanel avec les coordonnées flottantes indiquées. Le curseur graphique est placé en (0,0) |
makeGPanel(xmin, xmax, ymin, ymax, False) | Idem, mais en cachant la fenêtre (pour la rendre visible, appeler visible(True)) |
makeGPanel(Size(width, height)) | Idem que makeGPanel(), mais en spécifiant la taille de la fenêtre (en pixels) |
getScreenWidth() | Retourne la largeur de l’écran (en pixels) |
getScreenHeight() | Retourne la hauteur de l’écran (en pixels) |
window(xmin, xmax, ymin, ymax) | Change la plage de coordonnées utilisées pour la fenêtre |
getWindow() | Retourne reference de GWindow (JFrame) |
drawGrid(x, y) |
Dessiner une grille pour le système de coordonnées avec un marqueur tous les x pour l’axe horizontal et tous les y pour l’axe vertical. Les étiquettes des marqueurs sont déterminées par le type des paramètres x et y : int ou float |
drawGrid(x, y, color) |
Idem, en spécifiant la couleur color de la grille |
drawGrid(x1, x2, y1, y2) |
Idem, en indiquant la plage de coordonnées x1..x2, y1..y2 sur laquelle s’étend la grille |
drawGrid(x1, x2, y1, y2, color) |
Idem, en spécifiant la couleur color de la grille |
drawGrid(x1, x2, y1, y2, x3, y3) |
Idem, en spécifiant les unités utilisées pour la grille avec x3, y3 sur l’axe horizontal, respectivement vertical |
drawGrid(x1, x2, y1, y2, x3, y3, color) |
Idem, en spécifiant la couleur color de la grille |
drawGrid(p, ...) |
Idem que drawGrid() en utilisant le GPanel référencé par la variable p. Utile lors de l’utilisation conjointe de plusieurs panels |
visible(isVisible) | Affiche / Cache la fenêtre |
resizeable(isResizeable) | Spécifie si la fenêtre est redimensionnable. Valeur par défaut : non |
dispose() | Ferme la fenêtre et libère les ressources utilisées pour le dessin |
isDisposed() | Retourne True si la fenêtre est fermée par le bouton « fermer » de la barre de titre ou suite à l’appel de la fonction dispose() |
bgColor(color) | Règle la couleur d’arrière-plan. Le paramètre color est une chaîne de couleur X11 ou un objet couleur retourné par le constructeur makeColor() |
title(text) | Affiche text dans la barre de titre de la fenêtre |
makeColor(colorStr) | Retourne un objet de type couleur correspondant à la chaine de couleur X11 passée en paramètre |
windowPosition(ulx, uly) | Règle la position de la fenêtre par rapport aux coordonnées de l’écran (en pixels) |
windowCenter() | Centre la fenêtre au milieu de l’écran |
storeGraphis() | Stocke le graphique courant dans une mémoire tampon graphique |
recallGraphics() | Effectue le rendu du contenu de la mémoire tampon dans le canevas GPanel |
clearStore(color) | Efface la mémoire tampon graphique en y peignant avec la couleur indiquée |
delay(time) | Met le programme en pause pour l’intervalle de temps indiqué par time (en ms) |
getDividingPoint(pt1, pt2, ratio) | Retourne les coordonnées du point qui sépare le segment reliant les points p1 et p2 avec le rapport ratio. Le rapport peut être négatif ou supérieur à 1 |
getDividingPoint(c1, c2, ratio) | Idem, en utilisant les nombres complexes c1 et c2
|
toUser(winX, winY), toUserHeight(winHeight), toUserWidth(winWidth), toUserX(winX), toUserY(winY) | Transformations de coordonnées float à pixel |
toWindow(userX, userY), toWindowHeight(userHeight), toWindowWidth(userWidth), toWindowX(userX), toWindowY(userY) | Transformations de coordonnées pixel à float |
clear() | Réinitialise la fenêtre graphique en effaçant son contenu et en replaçant le curseur graphique à l’origine (0, 0) |
erase() | Efface le contenu de la fenêtre graphique sans réinitialiser la position du curseur graphique |
putSleep() | Met le programme en pause jusqu’à l’appel ultérieur de la fonction wakeUp() |
wakeUp() | Remet le programme en route suite à une mise en pause avec putSleep() |
linfit(X, Y) | Effectue une régression linéaire y = a*x + b sur la base des données contenues dans les listes X et Y et retourne les coefficients de la droite sous la forme du tuple (a, b) |
addExitListener(onExit) | Enregistre une fonction de rappel onExit() qui est appelée à un clique sur fermeture de fenêtre. Pour fermer la fenêtre, appeler dispose() |
lineWidth(width) | Règle la largeur des lignes (en pixels) |
getLineWidth() | Retourne la largeur acutelle des lignes (en pixels) |
setColor(color) | Règle la couleur de dessin à color (chaîne de couleur X11 ou objet de type Color) |
move(x, y) | Place le curseur graphique à la position (x, y) sans dessiner de ligne |
move(liste) | Idem, en spécifiant les coordonnées dans la liste coord_list=[x, y] |
move(c) | Idem, en utilisant le nombre complexe c pour spécifier les coordonnées |
getPosX() | Retourne la coordonnée x de la position du curseur |
getPosY() | Retourne la coordonnée y de la position du curseur |
getPos() | Retourne les coordonnées de la position du curseur sous forme de liste |
draw(x, y), , lineTo(x, y) | Dessine une ligne depuis la position actuelle jusqu’au point (x, y) et met à jour la position du curseur avec (x, y) |
draw(list), lineTo(list) | Idem, en spécifiant les coordonnées dans une liste de la forme [x, y] |
draw(c), lineTo(c) | Idem, en spécifiant les coordonnées par le nombre complexe c |
line(x1, y1, x2, y2) | Dessine une ligne de (x1, y1) vers (x2, y2) sans modifier la position actuelle du curseur |
line(pt1, pt2) | Idem, en spécifiant les coordonnées des points de départ et d’arrivée de la ligne avec les listes pt1 = [x1, y1] et pt2 = [x2, y2] |
line(c1, c2) | Idem, en spécifiant les coordonnées des points de départ et d’arrivée de la ligne par les nombres complexes c1 et c2 |
line(li[p0, p1,...]) | Dessine le trajet partant du point p0 de tous les points de la liste (ou tuple) |
arrow(x1, y1, x2, y2, size) | Dessine une flêche de (x1, y1) à (x2, y2). size est la longueur des côtés du triangle (défaut: 10) |
arrow(pt1, pt2, size) | Dessine une flêche de pt1 à pt2. size est la longueur des côtés du triangle (défaut: 10) |
arrow(c1, c2, size) | Dessine une flêche de complex c1 à c2. size est la longueur des côtés du triangle (défaut: 10) |
doubleArrow(x1, y1, x2, y2, size) | Dessine une double flêche entre (x1, y1) et (x2, y2). size est la longueur des côtés des triangles (défaut: 10) |
doubleArrow(pt1, pt2, size) | Dessine une double flêche entre pt1 et pt2. size est la longueur des côtés des triangles (défaut: 10) |
doubleArrow(c1, c2, size) | Dessine une double flêche entre complex c1 et c2. size est la longueur des côtés des triangles (défaut: 10) |
circle(radius) | Dessine un cercle de rayon radius centré à la position actuelle du curseur graphique (radius defini par l'unité des coordonnées x) |
circle(x, y, radius), circle(center, radius) | Idem, en spécifiant le centre (liste ou complex) |
fillCircle(radius) | Dessine un disque plein de rayon radius centré à la position actuelle du curseur graphique. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
fillCircle(x, y, radius), fillCircle(centre, radius) | Idem, en spécifiant le centre (liste ou complex) |
ellipse(a, b) | Dessine une ellipse vide d’axes a et b centrée à la position actuelle du curseur graphique |
ellipse(x, y, a, b), ellipse(center, a, b) | Idem, en spécifiant le centre (liste ou complex) |
fillEllipse(a, b) | Dessine une ellipse pleine d’axes a et b centrée à la position actuelle du curseur graphique. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
fillEllipse(x, y, a, b), fillEllipse(center, a, b) | Idem, en spécifiant le centre (liste ou complex) |
rectangle(a, b) | Dessine un rectangle de côtés a et b centré à la position actuelle du curseur graphique |
rectangle(x1, y1, x2, y2) | Idem, en spécifiant le point supérieur gauche (x1, y1) et le point inférieur droit (x2, y2) |
rectangle(pt1, pt2) | Idem, en spécifiant les points de la diagonale par les listes à deux éléments p1 et p2 |
rectangle(c1, c2) | Idem, en utilisant les nombres complexes c1 et c2 pour spécifier les coordonnées |
fillRectangle(a, b) | Dessine un rectangle plein de côtés a et b centré à la position actuelle du curseur graphique. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
fillRrectangle(x1, y1, x2, y2) | Idem, en spécifiant le point supérieur gauche (x1, y1) et le point inférieur droit (x2, y2) |
fillRectangle(pt1, pt2) | Idem, en spécifiant les points de la diagonale par les listes à deux éléments p1 et p2 |
fillRrectangle(c1, c2) | Idem, en utilisant les nombres complexes c1 et c2 pour spécifier les coordonnées |
arc(radius, startAngle, extendAngle) | Dessine un arc de cercle de rayon radius centré à la position du curseur et d’angle au centre extendAngle. startAngle indique l’angle du point de départ par rapport à l’horizontale. Le sens positif est le sens contraire des aiguilles de la montre |
fillArc(radius, startAngle, extendAngle) | Idem, mais en dessinant un secteur circulaire plein. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
polygon(x-list, y-list) | Dessine le polygone dont les coordonnées des sommets sont spécifiées par les listes x_list, respectivement y_list |
polygon((li[pt1, pt2,..) | Idem en spécifiant les sommets dans une liste de points pti représentés par des listes de deux éléments [x,y] |
polygon(li[c1, c2, c3,...]) | Idem, en utilisant une liste de nombres complexes c1, c2, c3, … pour spécifier les coordonnées des sommets. |
fillPolygon(x-list, y-list) | Dessine le polygone dont les coordonnées des sommets sont spécifiées par les listes x_list, respectivement y_list. La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
fillPolygon((li[pt1, pt2,..) | Idem en spécifiant les sommets dans une liste de points pti représentés par des listes de deux éléments [x,y] |
fillPolygon(li[c1, c2, c3,...]) | Idem, en utilisant une liste de nombres complexes c1, c2, c3, … pour spécifier les coordonnées des sommets |
lowerPath, upperPath, hull = getHull(li[pt1, pt2,..]) | Retourne tuples lowerPath, upperPath et hull de la coque convexe des points pt1, pt2,... |
quadraticBezier(x1, y1, xc, yc, x1, y2) | Dessiner la courbe de Bézier quadratique définie par les points extrémaux (x1, y1) et (x2, y2) ainsi que le point de contrôle (xc, yc) |
quadraticBezier(pt1, pc, pt2) | Idem en spécifiant les points avec des listes de deux éléments |
quadraticBezier(c1, cc, c2) | Idem en spécifiant les points avec des nombres complexes |
cubicBezier(x1, y1, xc1, yc1, xc2, yc2, x2, y2) | Dessiner la courbe de Bézier cubique définie par les points extrémaux (x1, y1) et (x2, y2) ainsi que les deux points de contrôle (xc1, yc1) et (yc2, yc2) |
cubicBezier(pt1, ptc1, ptc2, pt2) | Idem en spécifiant les points avec des listes de deux éléments |
cubicBezier(c1, cc1, cc2, c2) | Idem en spécifiant les points avec des nombres complexes |
triangle(x1, y1, x2, y2, x3, y3) | Dessine un triangle de sommets (x1, y1), (x2, y2), (x3, y3) |
triangle(pt1, pt2, pt3) | Idem en spécifiant les sommets avec des listes de deux éléments |
triangle(c1, c2, c3) | Idem en spécifiant les sommets avec des nombres complexes |
fillTriangle(x1, y1, x2, y2, x3, y3) | Dessine un triangle plein dont les sommets sont spécifiés par les points (x1, y1), (x2, y2), (x3, y3). La couleur de remplissage utilisée est déterminée par la couleur actuelle du pinceau |
fillTriangle(pt1, pt2, pt3) | Idem en spécifiant les sommets avec des listes de deux éléments |
fillTriangle(c1, c2, c3) | Idem en spécifiant les sommets avec des nombres complexes |
point(x, y) | Dessine un point isolé (pixel) à la position (x, y) |
point(pt) | Idem en spécifiant les coordonnées par une liste de deux éléments |
point(complex) | Idem en spécifiant les coordonnées par un nombre complexe |
fill(x, y, color, replacementColor) |
Remplit la surface fermée contenant le point (x, y) en remplaçant tous les pixels actuellement de couleur color par un pixel de couleur replacementColor |
fill(pt, color, replacementColor) | Idem, en spécifiant les coordonnées du point par la liste de deux éléments pt |
fill(complex, color,replacementColor) | Idem, en spécifiant les coordonnées du point par le nombre complexe complex |
image(path, x, y) |
Insère l’image au format GIF, PNG ou JPEG stockée dans le fichier de chemin path. Place son coin inférieur gauche en (x,y). Le chemin path peut être relatif au dossier TigerJython, être contenu dans le dossier sprites de l’archive JAR de la distribution TigerJython ou être une URL débutant par http:// |
image(path, pt) | Idem, en spécifiant les coordonnées du coin inférieur gauche par la liste de deux éléments pt |
image(path, complex) | Idem, en spécifiant les coordonnées du coin inférieur gauche par le nombre complexe complex |
image(bm, x, y) | Insère Bitmap bm au format GIF- , PNG- ou JPG format. Place son coin inférieur gauche en (x,y). |
image(bm, pt) | Idem, en spécificant les coordonnées par la liste de deux éléments pt |
image(bm, complex) | Idem, en spécifiant les coordonnées du coin inférieur gauche par le nombre complexe complex |
imageHeighpath) | Retourne la hauteur de l’image présente dans le fichier path (en pixels) |
imageWidth(path) | Retourne la largeur de l’image présente dans le fichier path (en pixels) |
enableRepaint(boolean) | Active/désactive le rendu automatique du tampon graphique. Valeur par défaut : True = activé |
repaint() | Effectue le rendu du tampon graphique à l’écran. Nécessaire si le rendu automatique est désactivé |
setPaintMode() | Active le mode de dessin standard qui dessine par-dessus l’arrière-plan |
makeColor() | Crée une couleur. Exemples de valeurs : ("7FFED4"), ("Aqua-Marine"), (0x7FFED4), (8388564), (0.5, 1.0, 0.83), (128, 255, 212), ("rainbow", n) avec n = 0..1 qui indique une couleur de l’arc-en-ciel : n=0.1 correspond au violet et n=0.9 au rouge |
makeColor(color, alpha) | Crée une couleur transparente pour alpha entre 0 et 1 (makeColor("red", 0.25) ) |
setXORMode(color) | Active le mode de dessin XOR qui effectue une combinaison XOR entre les pixels de l’arrière-plan et la couleur de dessin color. Deux dessins successifs identiques en mode XOR s’annulent pour redonner la couleur d’arrière-plan initiale |
getPixelColor(x, y) | Retourne la couleur du pixel situé aux coordonnées (x, y) comme un objet de type Color |
getPixelColor(x, y).red | Retourne la rouge composante de couleur du pixel situé aux coordonnées (x, y) |
getPixelColor(x, y).green | Retourne la verte composante de couleur du pixel situé aux coordonnées (x, y) |
getPixelColor(x, y).blue | Retourne la bleue composante de couleur du pixel situé aux coordonnées (x, y) |
getPixelColor(pt) | Idem, pour le point dont les coordonnées sont indiquées dans la liste à deux éléments pt |
getPixelColor(complex) | Idem, pour le point dont les coordonnées sont indiquées par le nombre complexe complex |
getPixelColorStr(x, y) | Retourne la couleur du pixel situé aux coordonnées (x, y) comme une chaîne de couleur X11 |
getPixelColorStr(pt) | Idem, pour le point dont les coordonnées sont indiquées dans la liste à deux éléments pt |
getPixelColorStr(complex) | Idem, pour le point dont les coordonnées sont indiquées par le nombre complexe complex |
Node(center, text, size, borderSize, borderColor, textColor, bgColor, font) | Génère et dessine une image avec un cercle (rempli) et le texte ajusté au centre. Défauts: size = 50, borderSize = 1, borderColor = "black", textColor = "black", bgColor = "white", font = Font("Courier", Font.PLAIN, 14). Retourne une instance de Node |
Edge(node1, node2, lineWidth, color) | Crée et dessine une aréte non-orientée entre les deux noeux. Défauts: lineWidth = 1, color = "black" |
DirectedEdge(node1, node2, lineWidth, color, headSize) | Crée et dessine une aréte orientée du noeud node1 à node2. Défauts: lineWidth = 1, color = "black", headSize = 10. headSize est la longueur des côtés du triangle |
DoubleDirectedEdge(node1, node2, lineWidth, color, headSize) | Crée et dessine une une aréte double-orientée entre les noeuds node1 et node2. Défauts: lineWidth = 1, color = "black", headSize = 10. headSize est la longueur des côtés des triangles |
text(string) | Insère le texte contenu dans la chaîne string à partir de la position actuelle du curseur graphique |
text(x, y, string) | Idem, en écrivant à partir du point de coordonnées (x, y) |
text(pt, string) | Idem en spécifiant les coordonnées du point de départ par une liste de deux éléments |
text(complex, string) | Idem en spécifiant les coordonnées du point de départ par un nombre complexe |
text(x, y, string, font, textColor, bgColor) | Affiche le texte contenu dans string à partir de la position (x, y) en utilisant la police font, la couleur de texte textColor et la couleur d’arrière-fond bgColor |
text(pt, string, font, textColor, bgColor) | Idem en spécifiant les coordonnées du point de départ par une liste de deux éléments |
text(complex,string, font, textColor, bgColor) | Idem en spécifiant les coordonnées du point de départ par un nombre complexe |
font(font) | Sélectionne une autre police pour les appels subséquents à text() |
makeGPanel(mouseNNN = onMouseNNN)
auch mehrere, durch Komma getrennt
|
Enregistre une fonction de rappel onMouseNNN(x,y) qui est appelée à chaque fois qu’un événement souris survient. Les valeurs possibles pour NNN sont: Pressed, Released, Clicked, Dragged, Moved, Entered, Exited, SingleClicked, DoubleClicked |
isLeftMouseButton(), isRightMouseButton() |
Retourne True si le dernier événement souris a été généré par un clique gauche, respectivement droit |
makeGPanel(keyPressed = onKeyPressed)
|
Enregistre la fonction de rappel onKeyPressed(keyCode) qui est appelée |
getKeyModifiers() | Retourne un nombre entier lorsque des touches spéciales du clavier sont enfoncées (Ctrl, Majuscule, Alt). Il est également possible d’obtenir ainsi les combinaisons de touches spéciales, par exemple Ctrl + Maj |
makeGPanel(closeClicked = onCloseClicked) | Enregistre la fonction de rappel onCloseClicked() qui est appelée lorsque le bouton « fermer » de la barre des tâches est cliqué. On peut fermer la fenêtre à l’aide de l’appel dispose() |
showSimulationBar(NNN = onNNN) |
Montre un dialogue qui contient les boutons 'Step', 'Run'/'Pause', 'Reset' et une commande linéaire pour ajuster la période de simulation. Les fonctions de rappel suivantes peuvent être enregistrées: start, pause, step, reset, change(paramètre: simulationPeriod), loop, exit (bouton close pressé). loop est appelé dans chaque cycle par le thread de simulation |
showSimulationBar(ulx, uly, initPeriod, NNN = onNNN) | idem, mais avec la position du dialogue (coin gauche en haut) et periode de simulation (default: 100) |
hideSimulationBar() | Ferme le dialogue et libère les ressources |
getKey() | Retourne, sous forme de chaîne de caractères, le caractère correspondant à la dernière touche du clavier enfoncée |
getKeyCode() | Retourne le code (nombre entier) de la dernière touche du clavier enfoncée |
getKeyWait() | Met le programme en pause jusqu’à ce qu’une touche du clavier soit actionnée et retourne le caractère en question sous forme de chaine de caractères
|
getKeyCodeWait() | Idem, en retournant le code de la dernière touche enfoncée sous forme de nombre entier |
getModifiers() | Retourne un code si ctrl/alt/shift est actionné |
getModifiersText() | Retourne une description si ctrl/alt/shift est actionné |
kbhit() | Retourne True si une touche du clavier a été pressée depuis le dernier appel à getKey() ou getKeyCode() |
add(component) | Insère un composant GUI vers le bord supérieur de la fenêtre |
validate() | Redessine la fenêtre (et son contenu) après qu’un composant graphique a été rajouté avec add() |
addStatusBar(height) | Ajoute au bas de la fenêtre une barre d’état dont la hauteur est donnée par height (en pixels) |
setStatusText(text) | Affiche le texte text dans la barre d’état. Le texte qui y figurait est supprimé |
setStatusText(text, font, color) | Idem en indiquant la police et la couleur de texte à utiliser |
Font(name, style, size) | Crée un nouvel objet de type police de caractères utilisant la police nommée name, dans le style style et la taille de caractères size. Les différents paramètres ainsi que leur type sont décrits dans les trois lignes ci-dessous |
name | Chaîne de caractères décrivant une police de caractères installée sur le système, comme par exemple "Times New Roman", "Arial" ou "Courier" |
style | Nombre entier parmi les constantes suivantes: Font.PLAIN, Font.BOLD, Font.ITALIC. Ces constantes peuvent être combinées par addition, comme par exemple: Font.BOLD + Font.ITALIC |
size | Nombre entier correspondant à une taille disponible pour la police de caractères choisie, par exemple 12, 16, 72 |
msgDlg(message) | Ouvre une boîte de dialogue modale comportant un bouton OK et le message message |
msgDlg(message, title = title_text) | Idem, avec une barre de titre comportant le texte title_text |
inputInt(prompt) |
Ouvre une boîte de dialogue modale comportant des boutons OK et annuler. La fonction retourne le nombre entier saisi lors du clic sur OK ou interrompt le programme lors d’un clic sur annuler ou sur le bouton « fermer ». Si aucune valeur n’était présente lors de la validation ou s’il ne s’agissait pas d’un nombre entier, la boîte de dialogue réapparaît |
inputInt(prompt, False) |
Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
inputFloat(prompt) | Ouvre une boîte de dialogue modale comportant des boutons OK et annuler. La fonction retourne le nombre flottant saisi lors du clic sur OK ou interrompt le programme lors d’un clic sur annuler ou sur le bouton « fermer ». Si aucune valeur n’était présente lors de la validation ou s’il ne s’agissait pas d’un nombre flottant, la boîte de dialogue réapparaît |
inputFloat(prompt, False) | Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
inputString(prompt) | Ouvre une boîte de dialogue modale comportant des boutons OK et annuler. La fonction retourne la chaine de caractères saisie lors du clic sur OK ou interrompt le programme lors d’un clic sur annuler ou sur le bouton « fermer » |
inputString(prompt, False) | Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
input(prompt) | Ouvre une boîte de dialogue modale comportant des boutons OK et annuler. La fonction retourne le nombre entier, le flottant ou, à défaut, la chaine de caractères saisie lors du clic sur OK ou interrompt le programme lors d’un clic sur annuler ou sur le bouton « fermer » |
input(prompt, False) | Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
askYesNo(prompt) |
Ouvre une boîte de dialogue modale comportant les boutons oui/non. Le bouton « oui » retourne True et le bouton « non » retourne False. Le bouton « annuler » ou « fermer » terminent le programme |
askYesNo(prompt, False) | Idem, excepté que les boutons annuler/fermer ne terminent pas le programme mais retournent la valeur None |
img = getImage(filename) | returns a image representation of the give image file (formats: jpg, bmp, png, gif) |
img = readImage(data) | returns image representation from binary data (in jpg, gif, bmp, png format) |
imageToString(img, type) | returns image data in string representaion (type = "bmp", "gif", "jpg", "png) |
save(img, filename, type) | writes image to a file (type = "bmp", "gif", "jpg", "png) |
imgPaste = paste(img, imgReplace, x, y) | replaces a part of the image at position (x, y) with imgReplace. Returns a new image |
imgCrop = crop(img, x1, y1, x2, y2) | returns the image from the given rectangle |
imgScale = scale(img, factor, angle) | scales the image with the given factor and rotates it by a given angle (in degrees clockwise). Returns a new image |
saveData(data, filename) |
saves binary data to given file |
playTone(freq) | plays tone with given frequency (in Hz) and duration 1000 ms (blocking function) |
playTone(freq, blocking=False) | same, but not-blocking function, used to play several tones at (about) the same time |
playTone(freq, duration) | plays tone with given frequency and given duration (in ms) |
playTone([f1, f2, ...]) | plays several tones in a sequence with given frequency and duration 1000 ms |
playTone([(f1, d1), (f2, d2), ...]) | plays serveral tones in a sequence with given frequency and given duration |
playTone([("c", 700), ("e", 1500), ...]) | plays serveral tones in a sequence with given (Helmholtz) pitch naming and duration. Supported are: great octave, one-line to three-line octave (range C, C# up to h''' |
playTone([("c", 700), ("e", 1500), ...], instrument = "piano") | same, but selects instrument type. Supported are: piano, guitar, harp, trumpet, xylophone, organ, violin, panflute, bird, seashore, ... (see MIDI specifications) |
playTone([("c", 700), ("e", 1500), ...], instrument = "piano", volume=10) | same, but selects sound volume (0..100) |
Function | Action |
samples = getWavMono(filename) |
returns list of integer sound data from the given monaural sound file. With "wav/xxx.wav" loads files from the wav folder of tigerjython2.jar |
samples = getWavStereo(filename) | returns list of integer sound data from the given binaural sound file. With "wav/xxx.wav" loads files from the wav folder of tigerjython2.jar |
getWavInfo(file) | returns string with audio information about the given sound file |
openSoundPlayer(filename) | opens a sound player from the given sound file. The sound is played using the following sound functions. With "wav/xxx.wav" loads files from the wav folder of tigerjython2.jar |
openSoundPlayer(buffer) | same, but loads sound samples in WAV format from a byte array (type array.array) |
openMonoPlayer(samples, sampleRate) | creates a monaural sound player to play the list of integer values with given sample rate. The sound is played once using the play() function |
openStereoPlayer(samples, sampleRate) | creates a stereo sound player to play the list of integer values with given sample rate. The sound is played once using the play() function |
openSoundPlayerMP3(filename) | same as openSoundPlayer(), but with MP3 sound |
openMonoPlayerMP3(filename) | same as openMonotPlayer(), but with MP3 sound |
openStereoPlayerMP3(filename) | same as openStereoPlayer(), but with MP3 sound |
play() | plays sound from current position and returns immediately |
blockingPlay() |
plays sound from current position but blocks until it is finished |
advanceFrames(n) |
advances the current position for the given number of samples |
advanceTime(t) |
advances the current position for the given time interval |
getCurrentPos() |
returns the current position |
getCurrentTime() |
returns the current playing time |
rewindFrames(n) |
moves the current position back for the given number of samples |
rewindTime(t) | moves the current position back for the given time interval |
stop() | hält das Abspielen an und setzt die aktuelle Abspielposition an den Anfang |
setVolume(v) | sets the sound volume (v = 0..100) |
isPlaying() | return True, if the sound is still playing |
mute(bool) | if False, the sound is not audible; if True, it is audible again |
playLoop() | plays the sound in an endless loop |
replay() | restarts the sound |
delay(time) | stops the program for the given time (in milliseconds) |
Filename | Sample rate (Hz) | Description |
wav/bird.wav | 22050 | Short bird twitter |
wav/boing.wav | 22050 | Hit sound |
wav/cat.wav | 22050 | Meaw |
wav/click.wav | 22050 | Click |
wav/dog.wav | 22050 | Bark |
wav/dummy.wav | 40000 | Sine wave of 500 Hz and 1500 Hz (half amplitude) |
wav/explode.wav | 22050 | Explosion |
wav/fade.wav | 22050 | Fading away |
wav/flute.wav | 20000 | Flute playing G2 (352 Hz) |
wav/harris.wav | 20000 | Voice speaking "harris" |
wav/mmm.wav | 22050 | Short "mmm" to get hungry |
wav/notify.wav | 22050 | Short notification sound |
wav/oboe.wav | 20000 | Oboe playing G2 (352 Hz) |
ping.wav | 22050 | Short ping notification |
openMonoRecorder() | opens a monaural sound recorder |
openStereoRecorder() | opens a binaural sound recorder |
capture() | starts the recording |
stopCapture() | terminates the recording |
getCapturedBytes() | returns the recorded sound samples as byte list |
getCapturedSound() | returns the recorded sound as integer list (for stereo the channels are alternated) |
writeWavFile(samples, filename) | writes the sound to a WAV formatted file |
fft(samples, n) |
transforms the first n values of the given list of sound samples (floats). Returns a list of n//2 aequidistant spectral values (floats). If fs is the sampling rate, these values lay between 0 and fs/2 with mutual distance fs /n (resolution) |
fft_db(samples, n) | same, but returns the sprectral values in decibel 20*log(v) |
fft_filter(ydata, cutoff, isLowpass) |
performs filtering by Fourier transformation. For isLowPass = True the upper part of the spectrum is nulled out, for isLowpoass = False the lower part is nulled out. Then the spectrum is transformed back to time domain by an inverse Fourier transformation. cutoff in range 0...len(ydata) determines the cutoff frequency fc. For cutoff = len(ydata) the cutoff frequency is fs / 2 (fs: sampling frequency) |
toAequidistant(xrawdata, yrawdata, deltax) | returns two lists xdata, ydata with aequidistant values separated by deltax (linear interpolation) |
sine(A, f, t) | Sine wave with amplitude A and frequency f (phase 0) for every float value t |
square(A, f, t) | Square wave with amplitude A and frequency f (phase 0) for every float value t |
sawtooth(A, f, t) | Sawtooth wave with amplitude A and frequency f (phase 0) for every float value t |
triangle(A, f, t) | Triangle wave with amplitude A and frequency f (phase 0) for every float value t |
chirp(A, f, t) | Sine wave with amplitude A and time-linear increasing frequency (starting value f) for every float value t |
Function | Action |
coeffs = polynomfit(xdata, ydata, n) | fits a polynom of order n and returns the fitted values in ydata. Return value: list with n + 1 polynom coefficients |
spline = splinefit(xdata, ydata) | fits a spline function that passes the data points. Returns the spline function with definition interval min(xdata)..max(xdata). Outside spline(x) returnes 0 |
fft_filter(ydata, cutoff, isLowPass) | applies a low or high pass filter to the aequidistant data points. cutoff in range 0..n, where n = len(ydata). Return values in ydata |
functionfit(func, derivatives, initialGuess, xdata, ydata) | fits the function func(x, param) with n parameters in list param. derivatives(x, param) returns a list with the values of the partial derivatives to the n parameters. initGuess is a list with n guessed values for the n parameters |
functionfit(func, derivatives, initialGuess, xdata, ydata, weights) | same but with a list weights that determines the relative weights of the data points |
toAequidistant(xrawdata, yrawdata, deltax) |
returns two lists xdata, ydata with aequidistant values separated by deltax (linear interpolation) |
server = TCPServer(port, stateChanged, isVerbose = False) | creates a TCP socket server that listens on TCP port for a connecting client. State changes are notified by the callback stateChanged(). For isVerbose = True, debug messages are written to output window |
stateChanged(state, msg) |
Callback called at state change events. |
server.disconnect() | closes the connection with the client and enters the LISTENING state |
server.isConnected() | True, if a client is connected to the server |
server.terminate() | closes the connection and terminates the LISTENING state. Releases the IP port |
server.isTerminated() | True, if the server has been terminated |
server.sendMessage(msg) | sends the information msg to the client (as string, the character \0 (ASCII 0) serves as end of string indicator, it is transparently added and removed) |
TCPServer.getVersion() | returns the module version as string |
client = TCPClient(ipAddress, port, stateChanged, isVerbose = False) |
creates a TCP socket client prepared for a connection with a TCPServer at given address (string) and port (integer). State changes are notified by the callback stateChanged(). For isVerbose = True, debug messages are written to the output window |
stateChanged(state, msg) | Callback called at state change events. state: TCPClient.CONNECTING, msg: IP address:port of server state: TCPClient.CONNECTION_FAILED, msg: IP address:port of server state: TCPClient.CONNECTED, msg: IP address:port of server state: TCPClient.SERVER_OCCUPIED, msg: IP address:port of server state: TCPClient.DISCONNECTED, msg: empty state: TCPClient.MESSAGE, msg: message received from server (string) |
client.connect() | creates a connection to the server (blocking until timeout). Returns True, if the connection is established; otherwise returns False |
client.connect(timeout) | same, but with timeout (in s) to establish the connection |
client.isConnecting() | True during a connection trial |
client.isConnected() | True, if the client is connected to a server |
client.disconnect() | closes the connection with the server |
client.sendMessage(msg, responseTime) | sends the information msg to the server (as string, the character \0 (ASCII 0) serves as end of string indicator, it is transparently added and removed). For responseTime > 0 the method blocks and waits for maximum responseTime seconds for a server reply. Returns the message or None, if a timeout occured |
TCPClient.getVersion() | returns the module version as string |
server = HTTPServer(requestHandler, serverName = "PYSERVER", port = 80, isVerbose = False) |
creates a HTTPServer (Web server, inherited from TCPServer) that listens for a connecting client on given port
(default = 80). Starts a thread that handles and returns HTTP GET requests. requestHandler() is a callback function called when a GET request is received. If stateHandler = None, nothing is done. The function may include longer lasting server actions or a wait time, if sensors are not immediately ready for a new measuremen. |
getClientIP() | returns the dotted IP of a connected client. If no client is connected, returns empty string |
getServerIP() | returns the server's IP address (static method) |
(all methods of TCPServer) |
Class HTTPClient
Funktion | Aktion |
HTTPClient.getRequest(url, data = None) |
sends a GET request to the server. url is either "http://serveraddress?key1 = value1&key2 = value2 ..." or just "http://serveraddress" and data is a directory {key1: value1, key2: value2, ..}. In this case, key and value are automatically URL encoded. For SSL (port: 443) http: is replaced by https :. |
HTTPClient.postRequest(url, data = None) | sends a POST request to the server. url is either "http://serveraddress?key1 = value1 & key2 = value2 ..." or just "http://serveraddress" and data is a directory {key1: value1, key2: value2, ..}. In this case, key and value are automatically URL encoded. For SSL (port: 443) http: is replaced by https :. The return value is the HTTP response (without header). If an error occurs, the error description is returned. If an error occurs, the error description is returned |
HTTPClient.deletetRequest(url, data = "") | sends a DELETE request to the server. url is "http://serveraddress" and data is a string containing the file path of the file to delete. For SSL (port: 443), http: is replaced by https :. The return value is the HTTP response (without header). If an error occurs, the error description is returned |
HTTPClient.pushover(token_key, user_key, title, message) |
sends a push request to the pushover server api.pushover.net with given token key, user key, title and message. For verbose = True, debug information is printed. The return value is the HTTP response (without header). If an error occurs, the error description is returned |
Function | Action |
chn = ThingSpeakChannel(channelId, readKey, writeKey, userKey, verbose = False) |
creates an instance of the ThinkSpeakChannel class for communication with an existing channel on the cloud server www.thingspeak.com. The parameters correspond to the values received from the server during the channel definition. With verbose = True, debug informationen are written to the console. userKey is assigned to the user account and not to the channel (User API Key) |
chn.getData(nbEntries = -1, includeDate = True) |
returns the last nbEntries records as list of dictionaries [{fieldId: value} ...] (fieldId = 1..8). For nbEntries = -1, all records are returned. For includeDate = True, the field 'data', which contains the date-time of the record's creation, is also returned. All values are strings. In case of error, None is returned |
chn.getTable(nbEntries = -1, includeDate = True) |
the same, but returns an instance of DbTable with the table values. In case of error, an empty table is returned
|
chn.show(nbEntries = -1, includeDate = True) | the same, but shows the table contents in the console |
chn.getLastValue(fieldId = 1) |
returns the value of the last record with given fieldId (1..8). In case of error or if the table is empty, None is returned |
chn.getFields() |
returns a dictionary with the fields defined in the channel and their names: {'field1': <field name 1>, 'field2' :, <field name 2> ..}. In case of error, None is returned |
chn.insert(data, timeout = 20) |
makes a new table entry and returns True, if successful. data is either a single value (number or string) or a dictionary {fieldId: value, ...} for an entry in multiple fields. Fields that have no value are set to None. For free accounts, a new entry is only allowed every 15 seconds, for payed accounts every second; if the server is not yet ready to accept new data, the insertion trial is repeated every second until the timeout (in s) is reached and False is returned |
chn.clear() |
clears all table entries. If successful returns True |
server = BTServer(serviceName, stateChanged, isVerbose = False) | creates a Bluetooth server that exposes the RFCOMM service with name serviceName. State changes are notified by the callback stateChanged(). For isVerbose = True, debug messages are written to the output window |
stateChanged(state, msg) |
Callback called at state change events. |
server.disconnect() | closes the connection with the client and enters the LISTENING state |
server.isConnected() | True, if a client is connected to the server |
server.terminate() | closes the connection and terminates the LISTENING state. Releases internal resources |
server.isTerminated() | True, if the server has been terminated |
server.sendMessage(msg) | sends the information msg to the client (as string, the character \0 (ASCII 0) serves as end of string indicator, it is transparently added and removed) |
BTServer.getVersion() | returns the module version as string |
client = BTClient(stateChanged, isVerbose = False) |
creates a Bluetooth client prepared for a connection with a |
client.findServer(serverName, timeout) | performs a device inquiry for the given server Bluetooth name. Returns the tuple serverInfo: ("nn:nn:nn:nn:nn:nn", channel) , e.g. ("B8:27:EB:04:A6:7E", 1). If the server is not found, None is returned. The search is repeated until the timeout (in s) is reached |
client.findService(serviceName, timeout) |
performs a service inquiry for a Bluetooth server exposing the given RFCOMM service. Returns the tuple serverInfo: ("nn:nn:nn:nn:nn:nn", channel) , e.g. ("B8:27:EB:04:A6:7E", 1). If the service is not found, None is returned. The search is repeated until the timeout (in s) is reached |
stateChanged(state, msg) | Callback called at state change events. state: "CONNECTING" , msg: server info (MAC address, Bluetooth channel) state: "CONNECTED" , msg: server info state: "CONNECTION_FAILED", msg: sever info state: "DISCONNECTED", msg: empty state: "MESSAGE", msg: message received |
client.connect(serverInfo, timeout) | Performs a connection trial to the server with given serverInfo. If the connection trial fails, it is repeated until the timeout (in s) is reached. Returns True, if the connection is established; otherwise False is returned. serverInfo is a tuple with the MAC address and channel number ("nn:nn:nn:nn:nn:nn", channel) , e.g. ("B8:27:EB:04:A6:7E", 1) |
client.isConnecting() | returns True during the connection trial |
client.isConnected() | returns True, if the client is connected to a server |
client.disconnect() | closes the connection |
client.sendMessage(msg,) | sends the information msg to the client (as string, the character \0 (ASCII 0) serves as end of string indicator, it is transparently added and removed) |
BTClient.getVersion() | returns the module version as string |
client = MQTTClient(messageReceived = None, username = "", password = "") |
creates a MQTTClient that publishes and/or subcribes MQTT topics. The client does not yet connect to a MQTT broker. The client handles ping requests and reconnection automatically. |
client.connect(host, port = 1883, keepalive = 60) |
starts a connection trial to the given MQTT broker at given port. host is the broker's IP address and port its IP port where it is listening (default: 1883). |
client.disconnect() | disconnects the client from the broker |
client.publish(topic, payload, qos = 0, retain = False) | sends a message with given topic and payload to the broker. payload is a string (if an int or float is given, it is converted to a string). qos is the quality of service level (number 0, 1, 2, default: 0). retain determines, if the message is the “last known good”/retained message for the topic (default: False) |
client.subscribe(topic, qos = 0) | subscribes the client to one or more topics. topic is a string or a list of tuples of format (topic, qos). qos is the quality of service level (number 0, 1, 2. default: 0); not used, if topic is a list of tuples' |
client.setVerbose(verbose) | enables/disables logger information printed at stdout |
The module paho-mqtt is also available. See API-Reference.
Example:
import paho.mqtt.client as mqtt
client = mqtt.Client()
client = GameClient(stateChanged, messageReceived, topic = "/ch/aplu/mqtt/gameclient") |
creates a GameClient instance to handle game state information and message exchange for two players games.
stateChanged(state) is a callback function that is triggered when the game state is
modified. state values: 'CONNECTING' (while connecting to broker), 'CONNECTED' (if connected to the broker, but
waiting for a partner), 'READY' (both players are ready to play), 'DISCONNECTED' (the partner disconnected). messageReceived(msg) is a callback function that is triggered when a message arrived.
topic is the MQTT topic used for information exchange (default: /ch/aplu/mqtt/gameclient) |
client.setName(name) | sets the player's name that is communicated to the partner when getting READY |
client.connect(host, port = 1883) |
enganges a connection trial to the MQTT broker with the given IP address and port (default: 1883) |
client.sendMessage(text) | sends a text information to the partner |
client.disconnect() | disconnects the client from the broker |
client.getState() | returns the current state of the GameClient. (One of 'IDLE', 'CONNECTING', 'CONNECTED', 'READY', 'DISCONNECTED' |
client.getPartnerName() | returns the game partner's name that is communicated when getting READY (empty if not yet READY) |
client.getPartnerAddress() | returns the game partner's IP address (in dotted format) that is communicated when getting READY (empty if not yet READY) |
Function | Action | ||||||||||||||||||||
info = weather.request(city, key = defaultKey, lang = 'en') |
makes a weather data request at http://openweathermap.org for the given location. The given authorization key is used. This can be obtained free of charge on this host. (If the parameter is omitted, a default key is used, which allows a maximum of 60 requests / min for all users.) Return value: Dictionary with the fields:
|