用python画一个爱心-python画心动的爱心

画心动的♥教程

前言

最近有个电视剧火了，随之而来呢，制作❤也火了，不知道你们看到过没。各种各样的都有，比如说这样的。

源代码

我们先看一下小破站的大神的效果。是这样的。爱心是会有周期性的跳动的。心动的感觉。那么直接话不多直接，上源代码，然后再分步骤讲解。

import randomfrom math import sin, cos, pi, logfrom 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 = "#E66691"  # 心的颜色

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 3*((2 * sin(2 * p)) / (2 * pi))

class Heart:    """    爱心类    """
    def __init__(self, generate_frame=10):        self._points = set()  # 原始爱心坐标集合        self._edge_diffusion_points = set()  # 边缘扩散效果点坐标集合        self._center_diffusion_points = set()  # 中心扩散效果点坐标集合        self.all_points = {}  # 每帧动态点坐标        self.build(3000)
        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(1, 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环境配好后，复制代码后运行，就有上方的效果。

分步骤解析

一、画❤

首先我们需要画一个跳动的❤，那么我们就需要先画出这个❤出来

具体怎么做呢，首先，我们百度一个函数图像是❤的函数，很简单就找到了，可能是，太火了吧。

“笛卡尔的爱心坐标公式” r＝a（1-sinθ）

用表达式写出来

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)

自己实在想不明白，就求解一下，函数里t的值是一个0~2pi的值

这个函数达到的目的就是每次调用都会生成，函数图像上面的一个随机的点。然后就是开始画个爱心，看看爱心效果嘛。

class Heart:    """    爱心类    """
    def __init__(self):        self._points = set()  # 原始爱心坐标集合        self.build(3000)
    def build(self, number):        # 爱心        for _ in range(number):            t = random.uniform(0, 2 * pi) #t的范围取0，2pi            x, y = heart_function(t)            self._points.add((x, y))
    def render(self, render_canvas):        for x, y in self._points:            size = 1            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_heart.render(render_canvas)
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()

简单介绍一下。代码的运行从开始进行，创建一个TK对象，并创建一个画布，挂到窗口，然后就创建一个，我们的爱心类在执行构造函数时，就会调用self.build(3000)函数，build函数接收一个参数，用于循环，build函数循环调用爱心函数。将返回的坐标，添加到self.集合中。这是，爱心类对象一被创建，就有3000个随机的点生成。于是调用draw()函数。调用了爱心类的()函数，循环取出点的坐标并调用画布中的()函数将所有的坐标以点形式画出来。

运行！

好，成功画出了❤用python画一个爱心，但是太丑了吧，这也，跟原始的天差地别。需要画出扩散的那些点才行。

二、画出扩散的点

会使用到log函数的特性。

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

; 都是配置变量，都是定值用python画一个爱心，是屏幕的中心x点和y点。

与先前的圆不同的代码，就是在build()函数中将扩散的坐标也添加到了中。

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._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._points.add((x, y))

画出的图片

是不是好看了不少，离成功越来越近了。接下来就是让他动起来，就能达到，效果了。简单来说就是利用了tk里面的`after`方法进行循环调用循环绘制，周期性的绘制，代码中的注释很多，很详细，两千字了，有点码不动了，就不详细介绍了。拿到源码，知道全过程，我们可以在他基础上，对他进行修改，新加改变，下次有空再叙。

admin会员

打赏 收藏 海报 链接