❤️动态爱心代码合集❤️
❤️AllenIverrui❤️ 个人博客 gitee B站 近期文章： 《docker 常规软件的安装》 《Linux配置静态ip》 《Docker-compose容器编排》
文章目录
- 爱心代码合集
-
- three.js
- html +javascript
- c++
- python -1
- python -2
爱心代码合集
所有代码均来源于网络，若侵犯到你的利益请联系删除
three.js
浏览地址 love.alleniverrui.top
html +javascript
浏览地址 love.alleniverrui.top/2
代码地址 https://gitee.com/alleniverrui/love
c++
所需环境 easyx
#include
#include
#include
#include
#include
//爱心点结构体
struct Point {
double x, y; //坐标
COLORREF color; //颜色
};
//颜色数组
COLORREF colors[7] = { RGB(255,32,83),RGB(252,222,250) ,RGB(255,0,0) ,RGB(255,0,0) ,RGB(255,2,2) ,RGB(255,0,8) ,RGB(255,5,5) };
//COLORREF colors[7] = { RGB(55,132,83),RGB(252,222,250) ,RGB(25,120,130) ,RGB(25,230,40) ,RGB(25,24,112) ,RGB(255,230,128) ,RGB(25,5,215) };
const int xScreen = 1200; //屏幕宽度
const int yScreen = 800; //屏幕高度
const double PI = 3.1426535159; //圆周率
const double e = 2.71828; //自然数e
const double averag_distance = 0.162; //弧度以0.01增长时，原始参数方程每个点的平均距离
const int quantity = 506; //一个完整爱心所需点的数量
const int circles = 210; //组成爱心主体的爱心个数（每个爱心会乘以不同系数）
const int frames = 20; //爱心扩张一次的帧数
Point origin_points[quantity]; //创建一个保存原始爱心数据的数组
Point points[circles * quantity]; //创建一个保存所有爱心数据的数组
IMAGE images[frames]; //创建图片数组
//坐标转换函数
double screen_x(double x)
{
x += xScreen / 2;
return x;
}
//坐标转换函数
double screen_y(double y)
{
y = -y + yScreen / 2;
return y;
}
//创建x1-x2的随机数的函数
int creat_random(int x1, int x2)
{
if (x2 > x1)
return rand() % (x2 - x1 + 1) + x1;
else
return 0;
}
//创建爱心扩张一次的全部数据，并绘制成20张图片保存
// 1 用参数方程计算出一个爱心的所有坐标并保存在 origin_points 中
// 2 重复对 origin_points 的所有坐标乘上不同的系数获得一个完整的爱心坐标数据，并保存在 points 中
// 3 通过一些数学逻辑计算 points 中所有点扩张后的坐标并绘制，并覆盖掉原来的数据（循环20次）
// 4 计算圆的外层那些闪动的点，不保存这些点的数据（循环20次）
void creat_data()
{
int index = 0;
//保存相邻的坐标信息以便用于计算距离
double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
for (double radian = 0.1; radian <= 2 * PI; radian += 0.005)
{
//爱心的参数方程
x2 = 16 * pow(sin(radian), 3);
y2 = 13 * cos(radian) - 5 * cos(2 * radian) - 2 * cos(3 * radian) - cos(4 * radian);
//计算两点之间的距离 开根号（(x1-x2)平方 + （y1-y1）平方）
double distance = sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
//只有当两点之间的距离大于平均距离才保存这个点，否则跳过这个点
if (distance > averag_distance)
{
//x1和y1保留当前数据
//x2和y2将在下一次迭代获得下一个点的坐标
x1 = x2, y1 = y2;
origin_points[index].x = x2;
origin_points[index++].y = y2;
}
}
index = 0;
for (double size = 0.1; size <= 20; size += 0.1)
{
//用sigmoid函数计算当前系数的成功概率
//用个例子说明一下，假设有100个点成功概率为 90%，那么就可能会有90个点经过筛选保留下来
// 假设有100个点成功概率为 20%，那么就可能会有20个点经过筛选保留下来
double success_p = 1 / (1 + pow(e, 8 - size / 2));
//遍历所有原始数据
for (int i = 0; i < quantity; ++i)
{
//用概率进行筛选
if (success_p > creat_random(0, 100) / 100.0)
{
//从颜色数组随机获得一个颜色
points[index].color = colors[creat_random(0, 6)];
//对原始数据乘上系数保存在points中
points[index].x = size * origin_points[i].x + creat_random(-4, 4);
points[index++].y = size * origin_points[i].y + creat_random(-4, 4);
}
}
}
//index当前值就是points中保存了结构体的数量
int points_size = index;
for (int frame = 0; frame < frames; ++frame)
{
//初始化每张图片宽xScreen，高yScreen
images[frame] = IMAGE(xScreen, yScreen);
//把第frame张图像设为当前工作图片
SetWorkingImage(&images[frame]);
//计算爱心跳动的坐标
for (index = 0; index < points_size; ++index)
{
double x = points[index].x, y = points[index].y; //把当前值赋值给x和y
double distance = sqrt(pow(x, 2) + pow(y, 2)); //计算当前点与原点的距离
double diatance_increase = -0.0009 * distance * distance + 0.35714 * distance + 5; //把当前距离代入方程获得该点的增长距离
//根据增长距离计算x轴方向的增长距离 x_increase = diatance_increase * cos（当前角度）
//cos（当前角度）= x / distance
double x_increase = diatance_increase * x / distance / frames;
//根据增长距离计算x轴方向的增长距离 x_increase = diatance_increase * sin（当前角度）
//sin（当前角度）= y / distance
double y_increase = diatance_increase * y / distance / frames;
//因为以上计算得到的是一整个过程的增长距离，而整个过程持续20帧，因此要除20
//用新的数据覆盖原来的数据
points[index].x += x_increase;
points[index].y += y_increase;
//提取当前点的颜色设置为绘画颜色
setfillcolor(points[index].color);
//注意，因为以上所有坐标是基于数学坐标的
//因此绘制到屏幕是就要转换为屏幕坐标
solidcircle(screen_x(points[index].x), screen_y(points[index].y), 1);
}
//产生外围闪动的点
for (double size = 17; size < 23; size += 0.3)
{
for (index = 0; index < quantity; ++index)
{
//当系数大于等于20，通过概率为百分之四十，当系数小于20，通过概率为百分之五
//20作为关键值是因为爱心主体的最大系数就是20
if ((creat_random(0, 100) / 100.0 > 0.6 && size >= 20) || (size < 20 && creat_random(0, 100) / 100.0 > 0.95))
{
double x, y;
if (size >= 20)
{
//用frame的平方的正负值作为上下限并加减15产生随机数
//用frame的平方的好处是frame越大，外围闪动的点运动范围越大
x = origin_points[index].x * size + creat_random(-frame * frame / 5 - 15, frame * frame / 5 + 15);
y = origin_points[index].y * size + creat_random(-frame * frame / 5 - 15, frame * frame / 5 + 15);
}
else
{
//对于系数小于20的处理与爱心点一样
x = origin_points[index].x * size + creat_random(-5, 5);
y = origin_points[index].y * size + creat_random(-5, 5);
}
//随机获取颜色并设置为当前绘图颜色
setfillcolor(colors[creat_random(0, 6)]);
//把数学坐标转换为屏幕坐标再进行绘制
solidcircle(screen_x(x), screen_y(y), 1);
//需要注意的是，我并没有保存这些点，因为这些点不需要前一帧的坐标数据
//只需要当前系数就可绘制出来，因此没 必要保存
}
}
}
}
}
int main()
{
initgraph(xScreen, yScreen); //创建屏幕
BeginBatchDraw(); //开始批量绘图
srand(time(0)); //初始化随机种子
creat_data(); //调用函数产生20张图片
SetWorkingImage(); //调用函数把工作图像恢复为窗口，没有添加参数默认为窗口
//因为接下是用窗口播放图片，因此要把绘图效果设置为窗口
bool extend = true, shrink = false;
for (int frame = 0; !_kbhit();) //退出条件为检测到按键信息
{
putimage(0, 0, &images[frame]); //播放第frame张图片
FlushBatchDraw(); //刷新批量绘图
Sleep(20); //延时20毫秒
cleardevice(); //清除屏幕，用来播放下一帧图片
//注意 creat data 产生的只是爱心扩张的20张图片，并没有产生爱心收缩的图片
//但是把扩张的图片倒着播放就产生的收缩的效果
//所以下面这个 if else 语句就是决定图片是正常播放还是倒着播放
if (extend) //扩张时， ++frame，正常播放
frame == 19 ? (shrink = true, extend = false) : ++frame;
else //收缩时， --frame，倒着播放
frame == 0 ? (shrink = false, extend = true) : --frame;
}
EndBatchDraw(); //关闭批量绘图
closegraph(); //关闭绘图窗口
return 0; //结束程序
}
python -1
import random
from math import sin, cos, pi, log
from tkinter import *
CANVAS_WIDTH = 640 # 画布的宽
CANVAS_HEIGHT = 480 # 画布的高
CANVAS_CENTER_X = CANVAS_WIDTH / 2 # 画布中心的X轴坐标
CANVAS_CENTER_Y = CANVAS_HEIGHT / 2 # 画布中心的Y轴坐标
IMAGE_ENLARGE = 11 # 放大比例
HEART_COLOR = "#ff6781" # 心的颜色，这个是粉红
def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):
"""
“爱心函数生成器”
:param shrink_ratio: 放大比例
:param t: 参数
:return: 坐标
"""
# 基础函数
x = 16 * (sin(t) ** 3)
y = -(13 * cos(t) - 5 * cos(2 * t) - 2 * cos(3 * t) - cos(4 * t))
# 放大
x *= shrink_ratio
y *= shrink_ratio
# 移到画布中央
x += CANVAS_CENTER_X
y += CANVAS_CENTER_Y
return int(x), int(y)
def scatter_inside(x, y, beta=0.15):
"""
随机内部扩散
:param x: 原x
:param y: 原y
:param beta: 强度
:return: 新坐标
"""
ratio_x = - beta * log(random.random())
ratio_y = - beta * log(random.random())
dx = ratio_x * (x - CANVAS_CENTER_X)
dy = ratio_y * (y - CANVAS_CENTER_Y)
return x - dx, y - dy
def shrink(x, y, ratio):
"""
抖动
:param x: 原x
:param y: 原y
:param ratio: 比例
:return: 新坐标
"""
force = -1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.6) # 这个参数...
dx = ratio * force * (x - CANVAS_CENTER_X)
dy = ratio * force * (y - CANVAS_CENTER_Y)
return x - dx, y - dy
def curve(p):
"""
自定义曲线函数，调整跳动周期
:param p: 参数
:return: 正弦
"""
# 可以尝试换其他的动态函数，达到更有力量的效果（贝塞尔？）
return 2 * (2 * sin(4 * p)) / (2 * pi)
class Heart:
"""
爱心类
"""
def __init__(self, generate_frame=20):
self._points = set() # 原始爱心坐标集合
self._edge_diffusion_points = set() # 边缘扩散效果点坐标集合
self._center_diffusion_points = set() # 中心扩散效果点坐标集合
self.all_points = {} # 每帧动态点坐标
self.build(2000)
self.random_halo = 1000
self.generate_frame = generate_frame
for frame in range(generate_frame):
self.calc(frame)
def build(self, number):
# 爱心
for _ in range(number):
t = random.uniform(0, 2 * pi) # 随机不到的地方造成爱心有缺口
x, y = heart_function(t)
self._points.add((x, y))
# 爱心内扩散
for _x, _y in list(self._points):
for _ in range(3):
x, y = scatter_inside(_x, _y, 0.05)
self._edge_diffusion_points.add((x, y))
# 爱心内再次扩散
point_list = list(self._points)
for _ in range(4000):
x, y = random.choice(point_list)
x, y = scatter_inside(x, y, 0.17)
self._center_diffusion_points.add((x, y))
@staticmethod
def calc_position(x, y, ratio):
# 调整缩放比例
force = 1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.520) # 魔法参数
dx = ratio * force * (x - CANVAS_CENTER_X) + random.randint(-1, 1)
dy = ratio * force * (y - CANVAS_CENTER_Y) + random.randint(-1, 1)
return x - dx, y - dy
def calc(self, generate_frame):
ratio = 10 * curve(generate_frame / 10 * pi) # 圆滑的周期的缩放比例
halo_radius = int(4 + 6 * (1 + curve(generate_frame / 10 * pi)))
halo_number = int(3000 + 4000 * abs(curve(generate_frame / 10 * pi) ** 2))
all_points = []
# 光环
heart_halo_point = set() # 光环的点坐标集合
for _ in range(halo_number):
t = random.uniform(0, 2 * pi) # 随机不到的地方造成爱心有缺口
x, y = heart_function(t, shrink_ratio=11.6) # 魔法参数
x, y = shrink(x, y, halo_radius)
if (x, y) not in heart_halo_point:
# 处理新的点
heart_halo_point.add((x, y))
x += random.randint(-14, 14)
y += random.randint(-14, 14)
size = random.choice((1, 2, 2))
all_points.append((x, y, size))
# 轮廓
for x, y in self._points:
x, y = self.calc_position(x, y, ratio)
size = random.randint(1, 3)
all_points.append((x, y, size))
# 内容
for x, y in self._edge_diffusion_points:
x, y = self.calc_position(x, y, ratio)
size = random.randint(1, 2)
all_points.append((x, y, size))
for x, y in self._center_diffusion_points:
x, y = self.calc_position(x, y, ratio)
size = random.randint(1, 2)
all_points.append((x, y, size))
self.all_points[generate_frame] = all_points
def render(self, render_canvas, render_frame):
for x, y, size in self.all_points[render_frame % self.generate_frame]:
render_canvas.create_rectangle(x, y, x + size, y + size, width=0, fill=HEART_COLOR)
def draw(main: Tk, render_canvas: Canvas, render_heart: Heart, render_frame=0):
render_canvas.delete('all')
render_heart.render(render_canvas, render_frame)
main.after(160, draw, main, render_canvas, render_heart, render_frame + 1)
if __name__ == '__main__':
root = Tk() # 一个Tk
canvas = Canvas(root, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)
canvas.pack()
heart = Heart() # 心
draw(root, canvas, heart) # 开始画画~
root.mainloop()
python -2
所需环境 open cv
from tkinter import *
from matplotlib import pyplot as plt
from PIL import Image
import random
import math
import numpy as np
import os
import colorsys
import cv2
from scipy.ndimage.filters import gaussian_filter
from math import sin, cos, pi, log
canvas_width = 600
canvas_height = 600
world_width = 0.05
world_heigth = 0.05
# 中间心的参数
points = None
fixed_point_size = 20000
fixed_scale_range = (4, 4.3)
min_scale = np.array([1.0, 1.0, 1.0]) * 0.9
max_scale = np.array([1.0, 1.0, 1.0]) * 0.9
min_heart_scale = -15
max_heart_scale = 16
# 外围随机心参数
random_point_szie = 7000
random_scale_range = (3.5, 3.9)
random_point_maxvar = 0.2
# 心算法参数
mid_point_ignore = 0.95
# 相机参数
camera_close_plane = 0.1
camera_position = np.array([0.0, -2.0, 0.0])
# 点的颜色
hue = 0.92
color_strength = 255
# 常用向量缓存
zero_scale = np.array([0.0, 0.0, 0.0])
unit_scale = np.array([1.0, 1.0, 1.0])
color_white = np.array([255, 255, 255])
axis_y = np.array([0.0, 1.0, 0.0])
# 渲染缓存
render_buffer = np.empty((canvas_width, canvas_height, 3), dtype=int)
strength_buffer = np.empty((canvas_width, canvas_height), dtype=float)
# 随机点文件缓存
points_file = "temp.txt"
# 渲染结果
total_frames = 30
output_dir = "./output"
# 格式
image_fmt = "jpg"
def color(value):
digit = list(map(str, range(10))) + list("ABCDEF")
string = '#'
for i in value:
a1 = i // 16
a2 = i % 16
string += digit[a1] + digit[a2]
return string
def heart_func(x, y, z, scale):
bscale = scale
bscale_half = bscale / 2
x = x * bscale - bscale_half
y = y * bscale - bscale_half
z = z * bscale - bscale_half
return (x ** 2 + 9 / 4 * (y ** 2) + z ** 2 - 1) ** 3 - (x ** 2) * (z ** 3) - 9 / 200 * (y ** 2) * (z ** 3)
def lerp_vector(a, b, ratio):
result = a.copy()
for i in range(3):
result[i] = a[i] + (b[i] - a[i]) * ratio
return result
def lerp_int(a, b, ratio):
return (int)(a + (b - a) * ratio)
def lerp_float(a, b, ratio):
return (a + (b - a) * ratio)
def distance(point):
return (point[0] ** 2 + point[1] ** 2 + point[2] ** 2) ** 0.5
def dot(a, b):
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
def inside_rand(tense):
x = random.random()
y = -tense * math.log(x)
return y
# 生成中间心
def genPoints(pointCount, heartScales):
result = np.empty((pointCount, 3))
index = 0
while index < pointCount:
# 生成随机点
x = random.random()
y = random.random()
z = random.random()
# 扣掉心中间的点
mheartValue = heart_func(x, 0.5, z, heartScales[1])
mid_ignore = random.random()
if mheartValue < 0 and mid_ignore < mid_point_ignore:
continue
heartValue = heart_func(x, y, z, heartScales[0])
z_shrink = 0.01
sz = z - z_shrink
sheartValue = heart_func(x, y, sz, heartScales[1])
# 保留在心边上的点
if heartValue < 0 and sheartValue > 0:
result[index] = [x - 0.5, y - 0.5, z - 0.5]
# 向内扩散
len = 0.7
result[index] = result[index] * (1 - len * inside_rand(0.2))
# 重新赋予深度
newY = random.random() - 0.5
rheartValue = heart_func(result[index][0] + 0.5, newY + 0.5, result[index][2] + 0.5, heartScales[0])
if rheartValue > 0:
continue
result[index][1] = newY
# 删掉肚脐眼
dist = distance(result[index])
if dist < 0.12:
continue
index = index + 1
if index % 100 == 0:
print("{ind} generated {per}%".format(ind=index, per=((index / pointCount) * 100)))
return result
# 生成随机心
def genRandPoints(pointCount, heartScales, maxVar, ratio):
result = np.empty((pointCount, 3))
index = 0
while index < pointCount:
x = random.random()
y = random.random()
z = random.random()
mheartValue = heart_func(x, 0.5, z, heartScales[1])
mid_ignore = random.random()
if mheartValue < 0 and mid_ignore < mid_point_ignore:
continue
heartValue = heart_func(x, y, z, heartScales[0])
sheartValue = heart_func(x, y, z, heartScales[1])
if heartValue < 0 and sheartValue > 0:
result[index] = [x - 0.5, y - 0.5, z - 0.5]
dist = distance(result[index])
if dist < 0.12:
continue
len = 0.7
result[index] = result[index] * (1 - len * inside_rand(0.2))
index = index + 1
for i in range(pointCount):
var = maxVar * ratio
randScale = 1 + random.normalvariate(0, var)
result[i] = result[i] * randScale
return result
# 世界坐标到相机本地坐标
def world_2_cameraLocalSapce(world_point):
new_point = world_point.copy()
new_point[1] = new_point[1] + camera_position[1]
return new_point
# 相机本地坐标到相机空间坐标
def cameraLocal_2_cameraSpace(cameraLocalPoint):
depth = distance(cameraLocalPoint)
cx = cameraLocalPoint[0] * (camera_close_plane / cameraLocalPoint[1])
cz = -cameraLocalPoint[2] * (cx / cameraLocalPoint[0])
cameraLocalPoint[0] = cx
cameraLocalPoint[1] = cz
return cameraLocalPoint, depth
# 相机空间坐标到屏幕坐标
def camerSpace_2_screenSpace(cameraSpace):
x = cameraSpace[0]
y = cameraSpace[1]
# convert to view space
centerx = canvas_width / 2
centery = canvas_height / 2
ratiox = canvas_width / world_width
ratioy = canvas_height / world_heigth
viewx = centerx + x * ratiox
viewy = canvas_height - (centery + y * ratioy)
cameraSpace[0] = viewx
cameraSpace[1] = viewy
return cameraSpace.astype(int)
# 绘制世界坐标下的点
def draw_point(worldPoint):
cameraLocal = world_2_cameraLocalSapce(worldPoint)
cameraSpsace, depth = cameraLocal_2_cameraSpace(cameraLocal)
screeSpace = camerSpace_2_screenSpace(cameraSpsace)
draw_size = int(random.random() * 3 + 1)
draw_on_buffer(screeSpace, depth, draw_size)
# 绘制到缓存上
def draw_on_buffer(screenPos, depth, draw_size):
if draw_size == 0:
return
elif draw_size == 1:
draw_point_on_buffer(screenPos[0], screenPos[1], color_strength, depth)
elif draw_size == 2:
draw_point_on_buffer(screenPos[0], screenPos[1], color_strength, depth)
draw_point_on_buffer(screenPos[0] + 1, screenPos[1] + 1, color_strength, depth)
elif draw_size == 3:
draw_point_on_buffer(screenPos[0], screenPos[1], color_strength, depth)
draw_point_on_buffer(screenPos[0] + 1, screenPos[1] + 1, color_strength, depth)
draw_point_on_buffer(screenPos[0] + 1, screenPos[1], color_strength, depth)
elif draw_size == 4:
draw_point_on_buffer(screenPos[0], screenPos[1], color_strength, depth)
draw_point_on_buffer(screenPos[0] + 1, screenPos[1], color_strength, depth)
draw_point_on_buffer(screenPos[0], screenPos[1] + 1, color_strength, depth)
draw_point_on_buffer(screenPos[0] + 1, screenPos[1] + 1, color_strength, depth)
# 根据色调和颜色强度获取颜色
def get_color(strength):
result = None
if strength >= 1:
result = colorsys.hsv_to_rgb(hue, 2 - strength, 1)
else:
result = colorsys.hsv_to_rgb(hue, 1, strength)
r = min(result[0] * 256, 255)
g = min(result[1] * 256, 255)
b = min(result[2] * 256, 255)
return np.array((r, g, b), dtype=int)
# 可以根据深度做一些好玩的
def draw_point_on_buffer(x, y, color, depth):
if x < 0 or x >= canvas_width or y < 0 or y >= canvas_height:
return
# 混合
strength = float(color) / 255
strength_buffer[x, y] = strength_buffer[x, y] + strength
# 绘制缓存
def draw_buffer_on_canvas(output=None):
render_buffer.fill(0)
for i in range(render_buffer.shape[0]):
for j in range(render_buffer.shape[1]):
render_buffer[i, j] = get_color(strength_buffer[i, j])
im = Image.fromarray(np.uint8(render_buffer))
im = im.rotate(-90)
if output is None:
plt.imshow(im)
plt.show()
else:
im.save(output)
def paint_heart(ratio, randratio, outputFile=None):
global strength_buffer
global render_buffer
global points
# 清空缓存
strength_buffer.fill(0)
for i in range(fixed_point_size):
# 缩放
point = points[i] * lerp_vector(min_scale, max_scale, ratio)
# 球型场
dist = distance(point)
radius = 0.4
sphere_scale = radius / dist
point = point * lerp_float(0.9, sphere_scale, ratio * 0.3)
# 绘制
draw_point(point)
# 生成一组随机点
randPoints = genRandPoints(random_point_szie, random_scale_range, random_point_maxvar, randratio)
for i in range(random_point_szie):
# 绘制
draw_point(randPoints[i])
# 高斯模糊
for i in range(1):
strength_buffer = gaussian_filter(strength_buffer, sigma=0.8)
# 绘制缓存
draw_buffer_on_canvas(outputFile)
def show_images():
img = None
for i in range(total_frames):
save_name = "{name}.{fmt}".format(name=i, fmt=image_fmt)
save_path = os.path.join(output_dir, save_name)
img = cv2.imread(save_path, cv2.IMREAD_ANYCOLOR)
cv2.imshow("Img", img)
cv2.waitKey(25)
def gen_images():
global points
if not os.path.isdir(output_dir):
os.mkdir(output_dir)
# 尝试加载或生成中间心
if not os.path.exists(points_file):
print("未发现缓存点，重新生成中")
points = genPoints(fixed_point_size, fixed_scale_range)
np.savetxt(points_file, points)
else:
print("发现缓存文件，跳过生成")
points = np.loadtxt(points_file)
for i in range(total_frames):
print("正在处理图片... ", i)
frame_ratio = float(i) / (total_frames - 1)
frame_ratio = frame_ratio ** 2
ratio = math.sin(frame_ratio * math.pi) * 0.743144
randratio = math.sin(frame_ratio * math.pi * 2 + total_frames / 2)
save_name = "{name}.{fmt}".format(name=i, fmt=image_fmt)
save_path = os.path.join(output_dir, save_name)
paint_heart(ratio, randratio, save_path)
print("图片已保存至", save_path)
if __name__ == "__main__":
gen_images()
while True:
show_images()