Introducción al uso de la biblioteca Python Tree para dibujar árboles de múltiples bifurcaciones

Introducción al uso de la biblioteca Python Tree para dibujar árboles de múltiples bifurcaciones

La biblioteca Tree es una biblioteca de terceros para Python. Esta biblioteca se utiliza principalmente para generar árboles y dibujar gráficos de árboles.

Uno, instale el árbol

pip install Tree

Para utilizar la biblioteca Tree, debe cooperar con la biblioteca PIL para lograr el dibujo.

2. Caso oficial

Echemos un vistazo a la demostración proporcionada por la biblioteca Tree en PyPI. Dirección 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()

resultado de la operación:

Ejecute el código para generar un árbol del trigémino y luego use PIL para mostrar el árbol como una imagen. A continuación, introduzca el uso de la biblioteca Tree.

Tres, introducción a la biblioteca de árboles

La biblioteca Tree se divide en tres partes, core.py, utils.py y draw.py.

La función de conversión de color y nodo de clase de nodo se implementan en utils.py.

La clase Drawer para dibujar gráficos se implementa en draw.py.

En core.py, se implementan el árbol en forma de árbol y la función de generación de ramas.

Las tres partes están acopladas. No necesita llamar directamente a las clases y funciones en utils.py y draw.py cuando las usa, simplemente use la clase Tree en core.py directamente.

from Tree.core import Tree

En la biblioteca Tree, las matemáticas de la biblioteca estándar de Python y la biblioteca de terceros PIL se utilizan en muchos lugares. No solo eso, cuando llamamos a la biblioteca Tree, también necesitamos usar la biblioteca matemática y la biblioteca PIL para generar una imagen del árbol.

Para el uso de la biblioteca de matemáticas, consulte: https://blog.csdn.net/weixin_43790276/article/details/98476264

Para el uso de la biblioteca PIL, consulte: https://blog.csdn.net/weixin_43790276/article/details/108478270

Cuarto, el uso de la biblioteca Tree.

Cree una instancia de un objeto de la clase Tree para generar un árbol. Al inicializar un árbol, hay 3 parámetros, pos, branch y sigma.

pos es una tupla de longitud 4 (también es posible una lista), que representa las coordenadas de píxeles horizontales y verticales (x0, y0, x1, y1) del punto inicial y final del árbol. El código fuente utilizará Pythagorean basado en estas dos coordenadas. El teorema calcula la longitud del árbol (solo el tronco cuando el árbol no está creciendo). La relación posicional entre el punto de inicio y el punto final determinará la dirección de crecimiento del árbol, que se puede ajustar mediante el valores positivos y negativos de las coordenadas. Si la longitud de la tupla entrante es menor que 4, el índice se informará fuera de los límites (no se pueden encontrar suficientes datos). Si la longitud de la tupla es mayor que 4, se tomarán los primeros 4 valores, y más datos no serán válidos.

Branches es una lista o tupla. Cuantos valores haya en la lista, habrá tantas ramas como crezca el árbol. El parámetro de cada rama también es una lista o tupla. Se requieren dos datos en los parámetros. El primero representa el coeficiente de cambio de longitud de la rama en relación con la rama principal (generalmente menos de 1, y la rama es más corta que el tronco) , y el segundo representa la rama relativa. El ángulo de desplazamiento de la rama principal, el ángulo está en radianes (el ángulo digital se puede convertir con los radianes en la biblioteca matemática). Al inicializar un árbol, si no se pasa el valor de las ramas, el valor predeterminado es Ninguno, por lo que se informará un error al calcular las ramas en el código fuente. Si se pasa una lista vacía en el código fuente, se informará un error cuando se usa PIL para mostrar el árbol porque no se puede expandir, por lo que debe pasarse. Parámetro de ramas vacías.

sigma es una tupla (también es posible una lista, pero indicará que no se ajusta a la especificación PEP). Hay dos valores en la tupla, el primero se utiliza para ajustar la longitud de la rama y el el segundo se usa para ajustar el ángulo de la rama (multiplicar el Pi matemático). No es fácil controlar el efecto esperado usando el parámetro sigma, así que mantenga el valor predeterminado (0, 0) y generalmente no pase el valor.

grow (times = 1): se utiliza para hacer crecer el árbol, el valor predeterminado es crecer una vez, es decir, crecer una vez sobre la base del tronco, la última vez son las hojas y las otras son las ramas. Aunque crece una vez por defecto, cuando se llama al método draw_on () más tarde, habrá un error de división por 0, por lo que la necesidad mínima de crecer dos veces, el valor debe ser mayor o igual a 2.

El atributo de edad representa la edad del árbol. La edad es el número de veces que el árbol ha crecido ().

move_in_rectangle (): se utiliza para mover la posición del árbol, hacer que la posición del árbol se adapte al lienzo (mueve automáticamente la imagen al centro del lienzo), que es un método de ayuda al dibujo.

get_size (): se utiliza para obtener el tamaño del árbol, el resultado devuelto es una tupla que representa el ancho y el alto (ancho, alto) del árbol respectivamente.

Utilice la función new () en PIL para crear un lienzo para dibujar, con tres parámetros. El primer parámetro indica el modo de la imagen, usando "RGB" (abreviatura de los tres colores primarios de rojo, verde y azul, que representan imágenes en color verdadero). El segundo parámetro representa el tamaño del lienzo (calculado en píxeles), porque el tamaño del árbol cambiará después de que crezca desde el tronco, así que use get_size () para obtener dinámicamente el tamaño del árbol actual. El tercer parámetro representa el color del lienzo, el valor predeterminado es 0 y el lienzo negro se puede modificar según sea necesario.

draw_on (lienzo, color de tallo, color de hoja, grosor, edades = Ninguno): para dibujar la estructura del árbol en el lienzo, se requieren 4 parámetros.

lienzo, lienzo. Pase el lienzo que usa la biblioteca PIL new () (también se pueden usar otras bibliotecas de dibujos).

stem_color, representa el color del tronco y el gradiente de cambio de color de las ramas. Pase una tupla (el color RGB se puede representar mediante una tupla de longitud 3). Si la longitud de la tupla entrante es 3, entonces todas las ramas tendrán el mismo color y sin degradado. Si la longitud de la tupla entrante es 6, El degradado de color se realizará de acuerdo con la edad de la rama (consulte el código fuente _get_color (edad) en draw.py). Si la longitud de la tupla es menor que 6 y no 3, informará que el índice es fuera de rango. Si la longitud es superior a 6, los siguientes datos no serán válidos.

leaf_color, el color de las hojas. Pase una tupla con una longitud de 3. Si la longitud es menor que 3, se informará un error de transmisión de parámetro. Si la longitud es mayor que 3, los siguientes datos no serán válidos. Aquí también puede pasar un color hexadecimal código.

grosor, el grosor del tronco. Pase un número entero, cuanto mayor sea el valor, más grueso será el tronco.

Ahora que se presentan los métodos y propiedades básicos, veamos un ejemplo 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()

resultado de la operación:

tree age is:  5

V. Introducción a otros métodos de la biblioteca Tree

print('树干长度：', tree.length)
print('树叶长度：', tree.get_branch_length())
print(tree.get_branch_length(age=1))
print(tree.get_rectangle())

resultado de la operación:

树干长度： 300.0
树叶长度： 19.690703039999992
174.0
(0.0, 0.0, 626.4380061192694, 613.2190030596347)

El atributo de longitud indica la longitud del tronco del árbol.

get_branch_length (): Devuelve la longitud de la rama a la edad especificada, o la longitud de la hoja si no se especifica la edad. La edad especificada puede ser infinita (el resultado se derivará en función del coeficiente de cambio).

get_rectangle (): Después de que el árbol crece muchas veces, devuelve las coordenadas del rectángulo ocupado por el árbol.

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)

resultado de la operación:

树的节点数： 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 (): Devuelve el número total de nodos desde el tronco hasta la edad especificada. Si no se especifica una edad, devuelve el número de nodos en el árbol actual. La edad especificada puede ser infinita (el resultado se derivará en función del número de ramas).

El atributo de nodos representa todos los objetos de nodo en el árbol actual, y cada nodo de edad constituye una lista.

get_nodes (): Devuelve las coordenadas de todos los nodos del árbol actual, y cada nodo de edad constituye una lista.

get_branches (): Devuelve las coordenadas de todas las ramas del árbol actual, el formato de las coordenadas es (x0, y0, x1, y1), y las ramas de cada edad constituyen una lista. Este método no tiene nada que ver con el atributo ramas, el valor de las ramas es el parámetro que se pasa durante la inicialización.

move (delta): mueve el árbol, pasa un parámetro delta, el formato del parámetro es el mismo que pos (x0, y0, x1, y1) y los cuatro valores de coordenadas se traducen de acuerdo con el valor delta.

Seis, uso flexible de la biblioteca de árboles

1. Dibuja un árbol más bonito

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

resultado de la operación:

2. No se limita a los árboles, también se pueden dibujar otros gráficos

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

resultado de la operación:

El crecimiento y el dibujo de los árboles consumen mucha memoria, si el crecimiento del árbol es grande, la memoria será insuficiente.