Patrón de filotaxis en Python | Una unidad de Botánica Algorítmica

La filotaxis/filotaxia es la disposición de las hojas en el tallo de una planta y las espirales filotácticas forman una clase distintiva de patrones en la naturaleza. La palabra en sí proviene del griego phullon, que significa «hoja», y taxis, que significa «arreglo». Los arreglos filotáxicos florales básicos incluyen:
1. Filotaxis en espiral: en la filotaxia en espiral, los órganos florales individuales se crean en un intervalo de tiempo regular con el mismo ángulo divergente. El ángulo divergente en una flor con filotaxia en espiral se aproxima a 137,5 grados, lo que indica un patrón que sigue una serie de Fibonacci . La siguiente imagen muestra los patrones de filotaxia en espiral que tienen patrones en espiral en sentido horario y antihorario.

Puntos importantes a tener en cuenta:

1. Las series de Fibonacci típicamente describen espirales que se encuentran en la naturaleza. Se calcula como una serie en la que el par de números anterior se suma al siguiente número de la serie. La serie es 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89….
2. En realidad, hay un conjunto de espirales en el sentido de las agujas del reloj y otro conjunto en el sentido contrario a las agujas del reloj.
3. Las espirales de órganos florales siguen un conjunto de numerador y denominador de números de Fibonacci compensados ​​(1/2, 1/3, 2/5, 3/8, 5/13, 8/21, 13/34…). El numerador es el número de veces o vueltas alrededor del eje para volver al origen de iniciación. El denominador indica el número de órganos iniciados durante los turnos. Por tanto, un 2/5 indicaría 2 vueltas alrededor del eje y 5 órganos para volver al origen.
4. ej. – En el pino tenemos (2, 3), (5, 3) y (5, 8) filotaxes, en capituli los pares encontrados son (21, 34), (55, 34), (55, 89) , y (89, 144), y en piñas con escamas hexagonales se encuentran los tripletes (8, 13, 21) o (13, 21, 34), según el tamaño de los ejemplares.
5. La prevalencia de la secuencia de Fibonacci en la filotaxis a menudo se denomina «el misterio de la filotaxis».

Otros tipos de arreglos filotáxicos florales son:
2. Filotaxis en espiral, 3. Filotaxis en espiral simple, 4. Filotaxis en espiral compleja y 5. Filotaxis irregular

Formación del Patrón: Resumen

La hermosa disposición de las hojas en algunas plantas, llamada filotaxis, obedece a una serie de sutiles relaciones matemáticas. Por ejemplo, los floretes de la cabeza de un girasol forman dos espirales en direcciones opuestas: 55 de ellas en el sentido de las agujas del reloj y 34 en el sentido contrario. Asombrosamente,

1. Estos números son números de Fibonacci consecutivos.
2. Las proporciones de los números alternos de Fibonacci están dadas por los convergentes a φ^(-2), donde φ es la proporción áurea , y se dice que miden la fracción de vuelta entre hojas sucesivas en el tallo de una planta:
3. ej.: 1/2 para olmo y tilo, 1/3 para haya y avellano, 2/5 para roble y manzano, 3/8 para álamo y rosal, 5/13 para sauce y almendro, etc.
4. Cada hoja nueva en el tallo de una planta se coloca en un cierto ángulo con respecto a la anterior y ese ángulo es constante entre las hojas: generalmente alrededor de 137,5 grados.

Es decir, si observa la planta desde arriba y mide el ángulo formado entre una línea trazada desde el tallo hasta la hoja y la línea correspondiente a la siguiente hoja, encontrará que generalmente hay un ángulo fijo, llamado divergencia. ángulo.
Aquí, estamos interesados ​​en la filotaxia espiral y codificaremos para formar un patrón de filotaxia espiral en python usando gráficos de turtle.

Diseñando el Código

1. Codificaremos dos funciones, una para dibujar el patrón de filotaxia y la otra para dibujar los pétalos.
2. Los pétalos deben dibujarse solo después de que se complete el patrón de filotaxis. Por lo tanto, llamaremos a la función drawPetal() desde dentro de la función drawPhyllPattern() con las últimas coordenadas x e y visitadas después de dibujar el patrón de filotaxis.
3. La función drawPetal() dibujará los pétalos con funciones y características de Turtle, consulte Programación de turtle .

Para codificar el patrón de filotaxis, necesitamos seguir estas ecuaciones:

x = r*cos(θ)
y = r*sin(θ)

r, θ can also vary - so the to form phyllotactic pattern we substitutethe cartesian form
by polar form:

r = c*sqrt(n)
θ = n*137.508°

Reduces the problem to optimal packing on a disc, so
    r = c*sqrt(n) is from the area of the circle
        Area = πr² and n fills the Area in some units
        c1 * n/π = r²,    c is 1/sqrt(c1/π)
So, r = some constant c * sqrt(n)

Pseudocódigo: patrón de filotaxis

IMPORT MODULES ( MATH, TURTLE )

FUNCTION - DrawPhyllotaxisPattern( turtle, t length, petalstart, angle = 137.508, size, cspread)
    turtleColor("Black")
    FillColor('"Orange")
    Convert angle to radians (Φ)
    initialize ( xcenter,ycenter ) = ( 0,0 )
    Drawing the Pattern Starts:
    For n in Range ( 0,t ):
        r = cspread * sqrt(n)
        θ = n * Φ

        x = r * cos(θ) + xcenter
            y = r * sin(θ) + ycenter

        TURTLE POSITION(x,y)
        START DRAWING():
        if Drawing pattern ends:
            DrawFlowerPetals()
 
FUNCTION - DrawFlowerPetals(Turtle, x coordinate, y coordinate)
    DRAW using Turtle methods

Create Turtle  =  gfg
Call DrawPhyllotaxisPattern( gfg, t length, petalstart, angle = 137.508, size, cspread)

END

import math       
import turtle
  
def drawPhyllPattern(turtle, t, petalstart, angle = 137.508, size = 2, cspread = 4 ):
    """print a pattern of circles using spiral phyllotactic data"""
    # initialize position
    # turtle.pen(outline=1, pencolor="black", fillcolor="orange")
    turtle.color('black')
    turtle.fillcolor("orange")
    phi = angle * ( math.pi / 180.0 ) #we convert to radian
    xcenter = 0.0
    ycenter = 0.0
     
    # for loops iterate in this case from the first value until < 4, so
    for n in range (0, t):
        r = cspread * math.sqrt(n)
        theta = n * phi
          
        x = r * math.cos(theta) + xcenter
        y = r * math.sin(theta) + ycenter
  
        # move the turtle to that position and draw 
        turtle.up()
        turtle.setpos(x, y)
        turtle.down()
        # orient the turtle correctly
        turtle.setheading(n * angle)
        if n > petalstart-1:
            turtle.color("yellow")
            drawPetal(turtle, x, y)
        else: turtle.stamp()
              
  
def drawPetal(turtle, x, y ):
    turtle.penup()
    turtle.goto(x, y)
    turtle.pendown()
    turtle.color('black')
    turtle.fillcolor('yellow')
    turtle.begin_fill()
    turtle.right(20)
    turtle.forward(70)
    turtle.left(40)
    turtle.forward(70)
    turtle.left(140)
    turtle.forward(70)
    turtle.left(40)
    turtle.forward(70)
    turtle.penup()
    turtle.end_fill() # this is needed to complete the last petal
  
  
gfg = turtle.Turtle()
gfg.shape("turtle")
gfg.speed(0) # make the turtle go as fast as possible
drawPhyllPattern(gfg, 200, 160, 137.508 )
gfg.penup()
gfg.forward(1000)

import math       
import turtle
  
def drawPhyllotacticPattern( t, petalstart, angle = 137.508, size = 2, cspread = 4 ):
        """print a pattern of circles using spiral phyllotactic data"""
        # initialize position
        turtle.pen(outline=1, pencolor="black", fillcolor="orange")
        # turtle.color("orange")
        phi = angle * ( math.pi / 180.0 )
        xcenter = 0.0
        ycenter = 0.0
         
        # for loops iterate in this case from the first value until < 4, so
        for n in range (0, t):
                r = cspread * math.sqrt(n)
                theta = n * phi
                  
                x = r * math.cos(theta) + xcenter
                y = r * math.sin(theta) + ycenter
   
                # move the turtle to that position and draw 
                turtle.up()
                turtle.setpos(x, y)
                turtle.down()
                # orient the turtle correctly
                turtle.setheading(n * angle)
                if n > petalstart-1:
                        #turtle.color("yellow")
                        drawPetal(x, y)
                else: turtle.stamp()
                  
  
def drawPetal( x, y ):
        turtle.up()
        turtle.setpos(x, y)
        turtle.down()
        turtle.begin_fill()
        #turtle.fill(True)
        turtle.pen(outline=1, pencolor="black", fillcolor="yellow")
        turtle.right(20)
        turtle.forward(100)
        turtle.left(40)
        turtle.forward(100)
        turtle.left(140)
        turtle.forward(100)
        turtle.left(40)
        turtle.forward(100)
        turtle.up()
        turtle.end_fill() # this is needed to complete the last petal
  
  
  
turtle.shape("turtle")
turtle.speed(0) # make the turtle go as fast as possible
drawPhyllotacticPattern( 200, 160, 137.508, 4, 10 )
turtle.exitonclick() # lets you x out of the window when outside of idle

Producción:
Patrones de filotaxis.

Fuentes:

• Gráficos de python y Turtle por Deborah R. Fowler
• Patrón filotáctico por Deborah R. Fowler
• Implementación de Python por Deborah R. Fowler
• www.sciteneg.com/PhiTaxis/
• Filotaxis: la secuencia de Fibonacci en la naturaleza
• artículos de algoritmicbotany.org

Este artículo es una contribución de Amartya Ranjan Saikia . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.