Python繪製分形圖案探索無限細節和奇妙之美

import numpy as np
from PIL import Image
import math
def plot_line(from_coordinates, to_coordinates, thickness, colour, pixels):
    # 找出畫素陣列的邊界
    max_x_coordinate = len(pixels[0])
    max_y_coordinate = len(pixels)
    # 兩點之間沿著x軸和y軸的距離
    horizontal_distance = to_coordinates[1] - from_coordinates[1]
    vertical_distance = to_coordinates[0] - from_coordinates[0]
    # 兩點之間的總距離
    distance =  math.sqrt((to_coordinates[1] - from_coordinates[1])**2 
                + (to_coordinates[0] - from_coordinates[0])**2)
    # 每次給一個新的畫素上色時，將向前走多遠
    horizontal_step = horizontal_distance/distance
    vertical_step = vertical_distance/distance
    # 此時，將進入迴圈以在畫素陣列中繪製線
    # 迴圈的每一次迭代都會沿著線新增一個新的點
    for i in range(round(distance)):
        # 這兩個座標是直線中心的座標
        current_x_coordinate = round(from_coordinates[1] + (horizontal_step*i))
        current_y_coordinate = round(from_coordinates[0] + (vertical_step*i))
        # 一旦得到了點的座標，
        # 就在座標周圍畫出尺寸為thickness的圖案
        for x in range (-thickness, thickness):
            for y in range (-thickness, thickness):
                x_value = current_x_coordinate + x
                y_value = current_y_coordinate + y
                if (x_value > 0 and x_value < max_x_coordinate and 
                    y_value > 0 and y_value < max_y_coordinate):
                    pixels[y_value][x_value] = colour
# 定義影象的大小
pixels = np.zeros( (500,500,3), dtype=np.uint8 )
# 畫一條線
plot_line([0,0], [499,499], 1, [255,200,0], pixels)
# 把畫素陣列變成一張真正的圖片
img = Image.fromarray(pixels)
# 顯示得到的圖片，並儲存它
img.show()
img.save('Line.png')

def draw_triangle(center, side_length, thickness, colour, pixels):
    # 等邊三角形的高度是，h = ½(√3a)
    # 其中a是邊長
    triangle_height = round(side_length * math.sqrt(3)/2)
    # 頂角
    top = [center[0] - triangle_height/2, center[1]]
    # 左下角
    bottom_left = [center[0] + triangle_height/2, center[1] - side_length/2]
    # 右下角
    bottom_right = [center[0] + triangle_height/2, center[1] + side_length/2]
    # 在每個角之間畫一條線來完成三角形
    plot_line(top, bottom_left, thickness, colour, pixels)
    plot_line(top, bottom_right, thickness, colour, pixels)
    plot_line(bottom_left, bottom_right, thickness, colour, pixels)

def rotate(coordinate, center_point, degrees):
    # 從座標中減去旋轉的點
    x = (coordinate[0] - center_point[0])
    y = (coordinate[1] - center_point[1])
    # Python的cos和sin函數採用弧度而不是度數
    radians = math.radians(degrees)
    # 計算旋轉點
    new_x = (x * math.cos(radians)) - (y * math.sin(radians))
    new_y = (y * math.cos(radians)) + (x * math.sin(radians))
    # 將在開始時減去的偏移量加回旋轉點上
    return [new_x + center_point[0], new_y + center_point[1]]

def draw_triangle(center, side_length, degrees_rotate, thickness, colour, 
                  pixels, shrink_side_by, iteration, max_depth):
    # 等邊三角形的高度是，h = ½(√3a)
    # 其中'a'是邊長
    triangle_height = side_length * math.sqrt(3)/2
    # 頂角
    top = [center[0] - triangle_height/2, center[1]]
    # 左下角
    bottom_left = [center[0] + triangle_height/2, center[1] - side_length/2]
    # 右下角
    bottom_right = [center[0] + triangle_height/2, center[1] + side_length/2]
    if (degrees_rotate != 0):
        top = rotate(top, center, degrees_rotate)
        bottom_left = rotate(bottom_left, center, degrees_rotate)
        bottom_right = rotate(bottom_right, center, degrees_rotate)
    # 三角形各邊之間的座標
    lines = [[top, bottom_left],[top, bottom_right],[bottom_left, bottom_right]]
    line_number = 0
    # 在每個角之間畫一條線來完成三角形
    for line in lines:
        line_number += 1
        plot_line(line[0], line[1], thickness, colour, pixels)
        # 如果還沒有達到max_depth，就畫一些新的三角形
        if (iteration < max_depth and (iteration < 1 or line_number < 3)):
            gradient = (line[1][0] - line[0][0]) / (line[1][1] - line[0][1])
            new_side_length = side_length*shrink_side_by
            # 正在繪製的三角形線的中心
            center_of_line = [(line[0][0] + line[1][0]) / 2, 
                              (line[0][1] + line[1][1]) / 2]
            new_center = []
            new_rotation = degrees_rotate
            # 需要旋轉traingle的數量
            if (line_number == 1):
                new_rotation += 60
            elif (line_number == 2):
                new_rotation -= 60
            else:
                new_rotation += 180
            # 在一個理想的世界裡，這將是gradient=0，
            # 但由於浮點除法的原因，無法
            # 確保永遠是這種情況
            if (gradient < 0.0001 and gradient > -0.0001):
                if (center_of_line[0] - center[0] > 0):
                    new_center = [center_of_line[0] + triangle_height * 
                                 (shrink_side_by/2), center_of_line[1]]
                else:
                    new_center = [center_of_line[0] - triangle_height * 
                                  (shrink_side_by/2), center_of_line[1]]
            else:
                # 計算直線梯度的法線
                difference_from_center = -1/gradient
                # 計算這條線距中心的距離
                # 到新三角形的中心
                distance_from_center = triangle_height * (shrink_side_by/2)
                # 計算 x 方向的長度，
                # 從線的中心到新三角形的中心
                x_length = math.sqrt((distance_from_center**2)/ 
                                     (1 + difference_from_center**2))
                # 計算出x方向需要走哪條路
                if (center_of_line[1] < center[1] and x_length > 0):
                    x_length *= -1
                # 現在計算Y方向的長度
                y_length = x_length * difference_from_center
                # 用新的x和y值來偏移線的中心
                new_center = [center_of_line[0] + y_length, 
                              center_of_line[1] + x_length]
            draw_triangle(new_center, new_side_length, new_rotation, 
                          thickness, colour, pixels, shrink_side_by, 
                          iteration+1, max_depth)