Introduction à l'utilisation de la bibliothèque Python Tree pour dessiner des arbres multi-fourches
La bibliothèque Tree est une bibliothèque tierce pour Python. Cette bibliothèque est principalement utilisée pour générer des arbres et dessiner des graphiques d'arbres.
Un, installez Tree
pip install TreePour utiliser la bibliothèque Tree, vous devez coopérer avec la bibliothèque PIL pour réaliser le dessin.
2. Cas officiel
Jetons un coup d'œil à la démo fournie par la bibliothèque Tree dans PyPI. Adresse PyPI: https://pypi.org/project/Tree/
# coding=utf-8
from Tree.core import Tree
from math import radians as rad
from PIL import Image
def main():
branches = ((.5, rad(-30)), (.6, rad(30)), (.4, rad(60)))
tree = Tree(pos=(0, 0, 0, -500), branches=branches)
tree.grow(10)
tree.move_in_rectangle()
im = Image.new("RGB", tree.get_size(), (239, 239, 239))
tree.draw_on(im, (85, 25, 0, 128, 53, 21), (0, 62, 21), 10)
im.show()
if __name__ == '__main__':
main()résultat de l'opération:
Exécutez le code pour générer un arbre trijumeau, puis utilisez PIL pour afficher l'arborescence sous forme d'image. Ensuite, introduisez l'utilisation de la bibliothèque Tree.
Trois, introduction à la bibliothèque d'arbres
La bibliothèque Tree est divisée en trois parties, core.py, utils.py et draw.py.
La classe de nœuds Node et la fonction de conversion des couleurs sont implémentées dans utils.py.
La classe Drawer pour dessiner des graphiques est implémentée dans draw.py.
Dans core.py, l'arborescence et la fonction de génération de branche sont implémentées.
Les trois parties sont couplées. Vous n'avez pas besoin d'appeler directement les classes et les fonctions dans utils.py et draw.py lorsque vous les utilisez, utilisez simplement la classe Tree dans core.py directement.
from Tree.core import TreeDans la bibliothèque Tree, la bibliothèque mathématique standard Python et la bibliothèque tierce PIL sont utilisées à de nombreux endroits. De plus, lorsque nous appelons la bibliothèque Tree, nous devons également utiliser la bibliothèque mathématique et la bibliothèque PIL pour générer une image de l'arbre.
Pour l'utilisation de la bibliothèque mathématique, veuillez vous référer à: https://blog.csdn.net/weixin_43790276/article/details/98476264
Pour l'utilisation de la bibliothèque PIL, veuillez consulter: https://blog.csdn.net/weixin_43790276/article/details/108478270
Quatrièmement, l'utilisation de la bibliothèque Tree
Instanciez un objet de la classe Tree pour générer un arbre. Lors de l'initialisation d'un arbre, il y a 3 paramètres, pos, branches et sigma.
pos est un tuple de longueur 4 (une liste est également possible), représentant les coordonnées horizontales et verticales des pixels (x0, y0, x1, y1) du point de départ et du point de fin de l'arbre. Le code source utilisera Pythagore basé sur ces deux coordonnées. Le théorème calcule la longueur de l'arbre (uniquement le tronc lorsque l'arbre ne pousse pas). La relation de position entre le point de départ et le point d'arrivée déterminera la direction de croissance de l'arbre, qui peut être ajustée par le valeurs positives et négatives des coordonnées. Si la longueur du tuple entrant est inférieure à 4, l'index sera signalé hors limites (pas assez de données peuvent être trouvées). Si la longueur du tuple est supérieure à 4, les 4 premières valeurs seront prises, et plus de données seront invalides.
Branches est une liste ou un tuple. Autant de valeurs qu'il y en a dans la liste, il y aura autant de branches que l'arborescence grandit. Le paramètre de chaque branche est également une liste ou un tuple. Deux données sont requises dans les paramètres. La première représente le coefficient de changement de longueur de la branche par rapport à la branche parente (généralement inférieur à 1 et la branche est plus courte que le tronc) , et le second représente la branche relative. L'angle de décalage de la branche parente, l'angle est en radians (l'angle numérique peut être converti avec les radians dans la bibliothèque mathématique). Lors de l'initialisation d'une arborescence, si la valeur des branches n'est pas transmise, la valeur par défaut est None, de sorte qu'une erreur sera signalée lors du calcul des branches dans le code source. Si une liste vide est transmise dans le code source, une erreur sera signalée lors de l'utilisation de PIL pour afficher l'arborescence car il ne peut pas être développé, il doit donc être transmis. Paramètre de branches vides.
sigma est un tuple (une liste est également possible, mais elle indiquera qu'elle n'est pas conforme à la spécification PEP). Il y a deux valeurs dans le tuple, la première est utilisée pour ajuster la longueur de la branche, et la la seconde est utilisée pour ajuster l'angle de la branche (multiplier le calcul Pi). Il n'est pas facile de contrôler l'effet attendu à l'aide du paramètre sigma, alors gardez la valeur par défaut (0, 0), et ne transmettez généralement pas la valeur.
grow (times = 1): Utilisé pour faire pousser l'arbre, la valeur par défaut est de grandir une fois, c'est-à-dire de pousser une fois sur la base du tronc, la dernière fois ce sont les feuilles et les autres sont les branches. Bien qu'elle augmente une fois par défaut, lorsque la méthode draw_on () est appelée plus tard, il y aura une erreur de division par 0, donc le minimum doit augmenter deux fois, la valeur doit être supérieure ou égale à 2.
L'attribut age représente l'âge de l'arbre. L'âge est le nombre de fois où l'arbre a grandi ().
move_in_rectangle (): Utilisé pour déplacer la position de l'arbre, rendre la position de l'arbre adaptative au canevas (déplacer automatiquement l'image vers le centre du canevas), qui est une méthode d'aide au dessin.
get_size (): utilisé pour obtenir la taille de l'arbre, le résultat renvoyé est un tuple représentant respectivement la largeur et la hauteur (largeur, hauteur) de l'arbre.
Utilisez la fonction new () dans PIL pour créer un canevas pour le dessin, avec trois paramètres. Le premier paramètre indique le mode de l'image, en utilisant "RVB" (abréviation des trois couleurs primaires rouge, vert et bleu, représentant des images en couleurs vraies). Le deuxième paramètre représente la taille du canevas (calculée en pixels), car la taille de l'arbre changera après sa croissance à partir du tronc, utilisez donc get_size () pour obtenir dynamiquement la taille de l'arbre actuel. Le troisième paramètre représente la couleur du canevas, la valeur par défaut est 0 et le canevas noir peut être modifié selon les besoins.
draw_on (canvas, stem_color, leaf_color, thick, ages = None): Pour dessiner la structure de l'arbre sur le canvas, 4 paramètres sont nécessaires.
toile, toile. Passez dans le canevas qui utilise la bibliothèque PIL new () (d'autres bibliothèques de dessins peuvent également être utilisées).
tige_couleur, représente la couleur du tronc et le dégradé de changement de couleur des branches. Passez un tuple (la couleur RVB peut être représentée par un tuple de longueur 3). Si la longueur du tuple entrant est de 3, toutes les branches auront la même couleur et aucun dégradé. Si la longueur du tuple entrant est de 6, Le dégradé de couleur sera effectué en fonction de l'âge de la branche (reportez-vous au code source _get_color (age) dans draw.py). Si la longueur du tuple est inférieure à 6 et non à 3, il indiquera que l'index est hors limites. Si la longueur est supérieure à 6, les données suivantes ne seront pas valides.
leaf_color, la couleur des feuilles. Passez un tuple d'une longueur de 3. Si la longueur est inférieure à 3, une erreur de transmission de paramètre sera signalée. Si la longueur est supérieure à 3, les données suivantes ne seront pas valides. Ici, vous pouvez également transmettre une couleur hexadécimale code.
épaisseur, l'épaisseur du tronc. Passez un entier, plus la valeur est élevée, plus le tronc est épais.
Maintenant que les méthodes et propriétés de base sont introduites, regardons un exemple simple.
# coding=utf-8
from Tree.core import Tree
from math import radians
from PIL import Image
pos = [0, 0, 0, -300]
branches = [[0.58, radians(-45)], [0.58, radians(45)]]
tree = Tree(pos=pos, branches=branches)
tree.grow(5)
print('tree age is: ', tree.age)
tree.move_in_rectangle()
image = Image.new("RGB", tree.get_size(), 0)
tree.draw_on(image, (80, 20, 10, 120, 60, 30), '#003E15', 15)
image.show()résultat de l'opération:
tree age is: 5
V. Introduction aux autres méthodes de la bibliothèque Tree
print('树干长度：', tree.length)
print('树叶长度：', tree.get_branch_length())
print(tree.get_branch_length(age=1))
print(tree.get_rectangle())résultat de l'opération:
树干长度： 300.0
树叶长度： 19.690703039999992
174.0
(0.0, 0.0, 626.4380061192694, 613.2190030596347)L'attribut length indique la longueur du tronc d'arbre.
get_branch_length (): renvoie la longueur de la branche à l'âge spécifié, ou la longueur de la feuille si l'âge n'est pas spécifié. L'âge spécifié peut être infini (le résultat sera dérivé en fonction du coefficient de changement).
get_rectangle (): Une fois que l'arbre a grandi plusieurs fois, il renvoie les coordonnées du rectangle occupé par l'arbre.
print('树的节点数：', tree.get_node_sum())
print(tree.get_node_sum(3))
# print(tree.nodes)
print(tree.get_nodes())
# print(tree.get_branches())
delta = (10, 10, 10, 10)
tree.move(delta)résultat de l'opération:
树的节点数： 63
15
[[(313.2190030596347, 313.2190030596347)], [(190.18242313317546, 190.1824231331754), (436.255582986094, 190.1824231331754)], [(89.26242313317545, 190.18242313317535), (190.18242313317543, 89.26242313317539), (436.255582986094, 89.26242313317539), (537.175582986094, 190.1824231331754)], [(47.87291764591453, 231.5719286204362), (47.87291764591458, 148.79291764591443), (148.79291764591454, 47.87291764591453), (231.57192862043632, 47.87291764591453), (394.8660774988331, 47.87291764591453), (477.64508847335486, 47.87291764591453), (578.5650884733549, 148.79291764591449), (578.5650884733549, 231.57192862043632)], [(47.87291764591453, 265.5214166204362), (13.923429645914553, 231.5719286204362), (13.92342964591461, 148.79291764591443), (47.87291764591458, 114.84342964591445), (114.84342964591457, 47.87291764591453), (148.79291764591454, 13.923429645914553), (231.57192862043632, 13.923429645914553), (265.5214166204363, 47.87291764591453), (360.9165894988331, 47.87291764591453), (394.8660774988331, 13.923429645914553), (477.64508847335486, 13.923429645914553), (511.59457647335483, 47.87291764591453), (578.5650884733549, 114.84342964591451), (612.5145764733549, 148.79291764591449), (612.5145764733549, 231.57192862043632), (578.5650884733549, 265.5214166204363)], [(61.79634729182908, 279.44484626635074), (33.949487999999974, 279.44484626635074), (0.0, 245.49535826635076), (0.0, 217.64849897452166), (5.684341886080802e-14, 162.71634729182898), (5.684341886080802e-14, 134.86948799999988), (33.94948800000003, 100.91999999999985), (61.796347291829136, 100.91999999999985), (100.92000000000002, 61.79634729182908), (100.92000000000002, 33.949487999999974), (134.869488, 0.0), (162.7163472918291, 0.0), (217.64849897452174, 0.0), (245.49535826635088, 0.0), (279.44484626635085, 33.949487999999974), (279.44484626635085, 61.79634729182908), (346.99315985291855, 61.79634729182908), (346.99315985291855, 33.949487999999974), (380.9426478529185, 0.0), (408.7895071447477, 0.0), (463.7216588274403, 0.0), (491.5685181192694, 0.0), (525.5180061192693, 33.949487999999974), (525.5180061192693, 61.79634729182908), (564.6416588274403, 100.91999999999996), (592.4885181192694, 100.91999999999996), (626.4380061192694, 134.86948799999993), (626.4380061192694, 162.71634729182904), (626.4380061192694, 217.64849897452177), (626.4380061192694, 245.49535826635088), (592.4885181192694, 279.44484626635085), (564.6416588274403, 279.44484626635085)]]get_node_sum (): Renvoie le nombre total de nœuds depuis le tronc jusqu'à l'âge spécifié. Si aucun âge n'est spécifié, il renvoie le nombre de nœuds dans l'arborescence courante. L'âge spécifié peut être infini (le résultat sera dérivé en fonction du nombre de branches).
L'attribut nœuds représente tous les objets nœud de l'arborescence actuelle et chaque nœud d'âge constitue une liste.
get_nodes (): renvoie les coordonnées de tous les nœuds de l'arborescence courante, et chaque nœud d'âge constitue une liste.
get_branches (): Renvoie les coordonnées de toutes les branches de l'arbre courant. Le format des coordonnées est (x0, y0, x1, y1), et les branches de chaque âge constituent une liste. Cette méthode n'a rien à voir avec l'attribut branches. La valeur des branches est le paramètre passé lors de l'initialisation.
move (delta): Déplacez l'arborescence, passez un paramètre delta, le format du paramètre est le même que pos (x0, y0, x1, y1) et les quatre valeurs de coordonnées sont traduites en fonction de la valeur delta.
Sixième utilisation flexible de la bibliothèque Tree
1. Dessinez un plus bel arbre
# coding=utf-8
from Tree.core import Tree
from math import radians
from PIL import Image
branches = [[0.7, radians(-50)], [0.45, radians(10)], [0.6, radians(30)]]
tree = Tree(pos=(0, 0, 0, -300), branches=branches)
tree.grow(9)
tree.move_in_rectangle()
image = Image.new("RGB", tree.get_size(), (250, 250, 250))
tree.draw_on(image, (80, 20, 10, 120, 60, 30), '#003E15', 12)
image.show()résultat de l'opération:
2. Non limité aux arbres, d'autres graphiques peuvent également être dessinés
# coding=utf-8
from Tree.core import Tree
from math import radians
from PIL import Image
tree = Tree(pos=(0, 0, 0, -100), branches=[[1.1, radians(30)]])
tree.grow(24)
tree.move_in_rectangle()
tree.move((100, 100, 100, 100))
size = tuple([s+200 for s in tree.get_size()])
image = Image.new("RGB", size, (250, 250, 250))
tree.draw_on(image, (255, 0, 0), (255, 0, 0), 15)
image.show()résultat de l'opération:
La croissance et le dessin des arbres sont très gourmands en mémoire. Si le nombre de croissance des arbres est important, la mémoire sera insuffisante.
