来源丨掘金-奈何缘浅wyj：使用python和pygame绘制繁花曲线的方法 链接丨https://juejin.cn/post/6958990919462813709

    真实的繁花曲线使用一种称为繁花曲线规的小玩意绘制，繁花曲线规由相互契合大小两个圆组成，用笔插在小圆上的一个孔中，紧贴大圆的内壁滚动，就可以绘制出漂亮的图案。这个过程可以做一个抽象：有两个半径不相等的圆，大圆位置固定，小圆在大圆内部，小圆紧贴着大圆内壁滚动，求小圆上的某一点走过的轨迹。
    进一步分析，小圆的运动可以分解为两个部分：小圆圆心绕大圆圆心公转、小圆绕自身圆心自转。设大圆圆心为A，半径为Ra，小圆圆心为B，半径为Rb，轨迹点为C，半径为Rc(BC距离)，设小圆公转的弧度为θ [0,∞)，如图：
    使用python和pygame绘制繁花曲线的方法 - 图1
    因为大圆的圆心坐标是固定的，要求得小圆上的某点的轨迹，需要先求出小圆当前时刻的圆心坐标，再求出小圆自转的弧度，最后求出小圆上某点的坐标。
    第一步：求小圆圆心坐标
    小圆圆心的公转轨迹是一个半径为 RA- RB 的圆，求小圆圆心坐标，相当于是求半径为 RA- RB 的圆上θ 弧度对应的点的坐标。
    圆上的点的坐标公式为：
    x = r cos(θ), y = r sin(θ)
    小圆圆心坐标为：( xa+ (Ra - Rb) cos(θ), ya + (Ra - Rb) sin(θ) )
    第二步：求小圆自转弧度
    设小圆自转弧度为α，小圆紧贴大圆运动，两者走过的路程相同，因此有：
    Ra θ = Rb α
    小圆自转弧度α = (Ra / Rb) θ
    第三步：求点C坐标
    点C相对小圆圆心B的公转轨迹是一个半径为 Rc 的圆，类似第一步，有：
    轨迹点C的坐标为：( xa+ Rc     cos(θ), ya+ Rc* sin(θ))
    按照以上算法分析，用python代码实现如下：

    1. # -*- coding: utf-8 -*-
    2. import math
    3. '''
    4. 功能：
    5.   已知圆的圆心和半径，获取某弧度对应的圆上点的坐标
    6. 入参：
    7.   center：圆心
    8.   radius：半径
    9.   radian：弧度
    10. '''
    11. def get_point_in_circle(center, radius, radian):
    12.   return (center[0] + radius * math.cos(radian), center[1] - radius * math.sin(radian))
    13. '''
    14. 功能：
    15.   内外圆A和B，内圆A沿着外圆B的内圈滚动，已知外圆圆心、半径，已知内圆半径，已知公转弧度和绕点半径，计算绕点坐标
    16. 入参：
    17.   center_A：外圆圆心
    18.   radius_A：外圆半径
    19.   radius_B：内圆半径
    20.   radius_C：绕点半径
    21.   radian：公转弧度
    22. '''
    23. def get_point_in_child_circle(center_A, radius_A, radius_B, radius_C, radian):
    24.   # 计算内圆圆心坐标
    25.   center_B = get_point_in_circle(center_A, radius_A - radius_B, radian)
    26.   # 计算绕点弧度（公转为逆时针，则自转为顺时针）
    27.   radian_C = 2.0*math.pi - ((radius_A / radius_B * radian) % (2.0*math.pi))
    28.   # 计算绕点坐标
    29.   return get_point_in_circle(center_B, radius_C, radian_C)

    有两点需要注意：
    （1）屏幕坐标系左上角为原点，垂直向下为Y正轴，与数学坐标系Y轴方向相反，所以第14行Y坐标为减法；
    （2）默认公转为逆时针，则自转为顺时针，所以第30行求自转弧度时，使用了2π - α%(2π)；
    坐标已经计算出来，接下来使用pygame绘制。思想是以0.01弧度为一个步长，不断计算出新的坐标，把一系列坐标连起来就会形成轨迹图。
    为了能够形成一个封闭图形，还需要知道绘制点什么时候会重新回到起点。想了一个办法，以X轴正半轴为基准线，每次绘制点到达基准线，计算此时绘制点与起点的距离，达到一定精度认为已经回到起点，形成封闭图形。

    1. ''' 计算两点距离（平方和） '''
    2. def get_instance(p1, p2):
    3.   return (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1])
    5. '''
    6. 功能：
    7.   获取绕点路径的所有点的坐标
    8. 入参：
    9.   center：外圆圆心
    10.   radius_A：外圆半径
    11.   radius_B：内圆半径
    12.   radius_C：绕点半径
    13.   shift_radian：每次偏移的弧度，默认0.01，值越小，精度越高，计算量越大
    14. '''
    15. def get_points(center, radius_A, radius_B, radius_C, shift_radian=0.01):
    16.   # 转为实数
    17.   radius_A *= 1.0
    18.   radius_B *= 1.0
    19.   radius_C *= 1.0
    21.   P2 = 2*math.pi # 一圈的弧度为 2PI
    22.   R_PER_ROUND = int(P2/shift_radian/4) + 1 # 一圈需要走多少步（弧度偏移多少次）
    24.   # 第一圈的起点坐标
    25.   start_point = get_point_in_child_circle(center, radius_A, radius_B, radius_C, 0)
    26.   points = [start_point]
    27.   # 第一圈的路径坐标
    28.   for r in range(1, R_PER_ROUND):
    29.     points.append(get_point_in_child_circle(center, radius_A, radius_B, radius_C, shift_radian*r))
    31.   # 以圈为单位，每圈的起始弧度为 2PI*round，某圈的起点坐标与第一圈的起点坐标距离在一定范围内，认为路径结束
    32.   for round in range(1, 100):
    33.     s_radian = round*P2
    34.     s_point = get_point_in_child_circle(center, radius_A, radius_B, radius_C, s_radian)
    35.     if get_instance(s_point, start_point) < 0.1:
    36.       break
    37.     points.append(s_point)
    38.     for r in range(1, R_PER_ROUND):
    39.       points.append(get_point_in_child_circle(center, radius_A, radius_B, radius_C, s_radian + shift_radian*r))
    41.   return points

    再加上绘制代码，完整代码如下：

    1. # -*- coding: utf-8 -*-
    2. import math
    3. import random
    4. '''
    5. 功能：
    6.   已知圆的圆心和半径，获取某弧度对应的圆上点的坐标
    7. 入参：
    8.   center：圆心
    9.   radius：半径
    10.   radian：弧度
    11. '''
    12. def get_point_in_circle(center, radius, radian):
    13.   return (center[0] + radius * math.cos(radian), center[1] - radius * math.sin(radian))
    14. '''
    15. 功能：
    16.   内外圆A和B，内圆A沿着外圆B的内圈滚动，已知外圆圆心、半径，已知内圆半径、公转弧度，已知绕点半径，计算绕点坐标
    17. 入参：
    18.   center_A：外圆圆心
    19.   radius_A：外圆半径
    20.   radius_B：内圆半径
    21.   radius_C：绕点半径
    22.   radian：公转弧度
    23. '''
    24. def get_point_in_child_circle(center_A, radius_A, radius_B, radius_C, radian):
    25.   # 计算内圆圆心坐标
    26.   center_B = get_point_in_circle(center_A, radius_A - radius_B, radian)
    27.   # 计算绕点弧度（公转为逆时针，则自转为顺时针）
    28.   radian_C = 2.0*math.pi - ((radius_A / radius_B * radian) % (2.0*math.pi))
    29.   # 计算绕点坐标
    30.   center_C = get_point_in_circle(center_B, radius_C, radian_C)
    31.   center_B_Int = (int(center_B[0]), int(center_B[1]))
    32.   return center_B_Int, center_C
    33. ''' 计算两点距离（平方和） '''
    34. def get_instance(p1, p2):
    35.   return (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1])
    37. '''
    38. 功能：
    39.   获取绕点路径的所有点的坐标
    40. 入参：
    41.   center：外圆圆心
    42.   radius_A：外圆半径
    43.   radius_B：内圆半径
    44.   radius_C：绕点半径
    45.   shift_radian：每次偏移的弧度，默认0.01，值越小，精度越高，计算量越大
    46. '''
    47. def get_points(center_A, radius_A, radius_B, radius_C, shift_radian=0.01):
    48.   # 转为实数
    49.   radius_A *= 1.0
    50.   radius_B *= 1.0
    51.   radius_C *= 1.0
    53.   P2 = 2*math.pi # 一圈的弧度为 2PI
    54.   R_PER_ROUND = int(P2/shift_radian) + 1 # 一圈需要走多少步（弧度偏移多少次）
    56.   # 第一圈的起点坐标
    57.   start_center, start_point = get_point_in_child_circle(center_A, radius_A, radius_B, radius_C, 0)
    58.   points = [start_point]
    59.   centers = [start_center]
    60.   # 第一圈的路径坐标
    61.   for r in range(1, R_PER_ROUND):
    62.     center, point = get_point_in_child_circle(center_A, radius_A, radius_B, radius_C, shift_radian*r)
    63.     points.append(point)
    64.     centers.append(center)
    66.   # 以圈为单位，每圈的起始弧度为 2PI*round，某圈的起点坐标与第一圈的起点坐标距离在一定范围内，认为路径结束
    67.   for round in range(1, 100):
    68.     s_radian = round*P2
    69.     s_center, s_point = get_point_in_child_circle(center_A, radius_A, radius_B, radius_C, s_radian)
    70.     if get_instance(s_point, start_point) < 0.1:
    71.       break
    72.     points.append(s_point)
    73.     centers.append(s_center)
    74.     for r in range(1, R_PER_ROUND):
    75.       center, point = get_point_in_child_circle(center_A, radius_A, radius_B, radius_C, s_radian + shift_radian*r)
    76.       points.append(point)
    77.       centers.append(center)  
    78.   print(len(points)/R_PER_ROUND)    
    79.   return centers, points
    80. import pygame
    81. from pygame.locals import *
    82. pygame.init()
    83. screen = pygame.display.set_mode((600, 400))
    84. clock = pygame.time.Clock()
    85. color_black = (0, 0, 0)
    86. color_white = (255, 255, 255)
    87. color_red = (255, 0, 0)
    88. color_yello = (255, 255, 0)
    89. center = (300, 200)
    90. radius_A = 150
    91. radius_B = 110
    92. radius_C = 50
    93. test_centers, test_points = get_points(center, radius_A, radius_B, radius_C)
    94. test_idx = 2
    95. draw_point_num_per_tti = 5
    96. while True:
    97.   for event in pygame.event.get():
    98.     if event.type==pygame.QUIT:
    99.       pygame.quit() 
    100.       exit(0)
    102.   screen.fill(color_white)
    104.   pygame.draw.circle(screen, color_black, center, int(radius_A), 2)
    106.   if test_idx <= len(test_points):
    107.     pygame.draw.aalines(screen, (0, 0, 255), False, test_points[:test_idx], 1)
    108.     if test_idx < len(test_centers):
    109.       pygame.draw.circle(screen, color_black, test_centers[test_idx], int(radius_B), 1)
    110.       pygame.draw.aaline(screen, color_black, test_centers[test_idx], test_points[test_idx], 1)
    111.     test_idx = min(test_idx + draw_point_num_per_tti, len(test_points))
    113.   clock.tick(50)
    114.   pygame.display.flip()

    效果：
    使用python和pygame绘制繁花曲线的方法 - 图2