Triângulo de Sierpinski - Python

Nessa postagem está um código em Python com uma forma de construir o famoso fractal chamado Triângulo de Sierpinski. Sinta-se a vontade para comentar e dar sugestões para melhorar o código. Fique à vontade para usá-lo também. Não sou programador, apenas estudo quando posso. Acredito que essa construção geométrica seja bem interessante para mostrar aos estudantes, tanto de matemática quanto de programação, o que pode ser feito com Python. A explicação de como a construção desse fractal é feita está no próprio código. 

Triângulo de Sierpinski em Python

Esse é o código:

# importar o matplotlib
import matplotlib.pyplot as plt
import math

# Intro do app

print('\n'+ 10*'*' + ' Triângulo de Sierspinsk ' + 10*'*')
print('\nVamos construir o famoso fractal chamado "Triângulo de Sierpinski".')

texto1 = '\nPara isso, vamos considerar três pontos não colineares que formam os vértices de um triângulo equilátero.'
texto2 = 'Esses pontos possuem coordenadas no plano cartesiano iguais a (0,0), (8,0) e (4,8sqrt(3)).'
texto3 =  'Esses pontos foram escolhidos simplesmente para termos um triângulo equilátero.'
print(texto1)
print(texto2)
print(texto3)

print('\nNo plano cartesiano, temos:')

# Vértices dados do triângulo
P = [0, 0]
Q = [8, 0]
R = [4, 8 * math.sqrt(3)]

input('Pressione ENTER para ver os vértices do triângulo.')

plt.figure(figsize=(8,6))
plt.scatter([P[0], Q[0], R[0]], [P[1], Q[1], R[1]], s=3)
plt.xlabel("x")
plt.ylabel("y")
plt.title("Triângulo de Siepinski")
plt.show()

# Explicação do processo de construção do Triângulo de Sierpinski
print('O processo de construção do Triângulo de Sierspinski funciona da seguinte forma:')
print('\n1. Primeiramente escolhemos um ponto aleatóriamente sobre os lados do triângulo ou no interior do triângulo;')
print('2. Em seguida, marcamos os pontos médios entre o ponto escolhido e os vértices do triângulo;')
print('3. Após isso, marcamos os pontos médios entre os pontos obtidos no passo anterior e os vértices do triângulo;')
print('4. Agora é só repetir o passo anterior e teremos o Triângulo de Sierpinski.')

# Fim da intro do app

print('\nVamos começar. Escolha um ponto qualquer sobre os lados do triângulo ou no interior do triângulo.')

# Função que virifica se os dados de entrada estão corretos
def verificador():
    cont_x = False
    while cont_x == False:
        try:
            Sx = float(input("\nCoordenada x do ponto: "))
            cont_x = True
        except ValueError:
            print('Digite uma coordenada válida (use o ponto para separar as casas decimais). Tente novamente.')

    cont_y = False
    while cont_y == False:
        try:
            Sy = float(input("\nCoordenada y do ponto: "))
            cont_y = True
        except ValueError:
            print('Digite uma coordenada válida (use o ponto para separar as casas decimais). Tente novamente.')
    return [Sx, Sy]

# Funcão para verificar se o ponto está nos lados ou no interior do trângulo
def esta(ponto):
    if ponto[1] >= 0 and ponto[1] <= 4*math.sqrt(3)*ponto[0] and ponto[1] <= -4*math.sqrt(3)*(ponto[0]-8):
        return True
    else:
        return False

# Função para calcular o ponto médio
def ponto_medio(a, b):
    x_1 = (a[0]+b[0]) / 2
    y_1 = (a[1]+b[1]) / 2
    return [x_1, y_1]

# Função para plotar o ponto inicial
def ponto_inicial(x, y, x_0, y_0):
    plt.figure(figsize=(8, 6))
    plt.scatter(x, y, s=1)
    plt.scatter(x_0, y_0, s=1, c='red')
    plt.xlabel("x")
    plt.ylabel("y")
    plt.title("Triângulo de Sierpinski")
    plt.show()

def sierpinski(S, x_0, y_0):
    passos = 9
    inicio = [S]
    x = []
    y = []
    while passos >= 0:
        novos = []
        for ponto in inicio:
            novos.append(ponto_medio(P,ponto))
            novos.append(ponto_medio(Q,ponto))
            novos.append(ponto_medio(R,ponto))
        for i in range(len(novos)):
            x.append(novos[i][0])
            y.append(novos[i][1])
        inicio = novos
        plt.figure(figsize=(8,6))
        plt.scatter(x, y, s=0.2, c='black')
        plt.scatter([P[0], Q[0], R[0]], [P[1], Q[1], R[1]], s = 3, c='blue')
        plt.scatter(x_0, y_0, s=3, c='red')
        plt.xlabel("x")
        plt.ylabel("y")
        plt.title("Triângulo de Siepinski")
        plt.show()
        passos = passos - 1

def main():
    S = verificador()
    while esta(S) == False:
        print('O ponto', S, 'não está no triângulo. Tente novamente.')
        S = verificador()
    print('\nO ponto ' + '(' + str(S[0]) + ', ' + str(S[1]) + ') ' + 'está no triângulo.')
    input('\nPressione ENTER para ver o ponto S.')
    ponto_inicial([P[0], Q[0], R[0], S[0]], [P[1], Q[1], R[1], S[1]], [S[0]], [S[1]])
    input('\nPressione ENTER para ver a construção do Triângulo de Sierpinski passo a passo.')
    sierpinski(S, [S[0]], [S[1]])
    print('\nQuer construir novamente o triângulo de Sierpinski começando por ponto?')
    encerrar = input('Digite "s" para sim, "n" para não e pressione ENTER: ')
    if encerrar == 's':
        main()

main()

print('Muito obrigado.')

Gostou dessa postagem? Foi útil para você? Tem alguma dúvida? Deixe um comentário.