Scribd
Upload
53 views3 pages

Heart Animation with Python Tkinter

Uploaded by

jayshou2004
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
53 views3 pages

Heart Animation with Python Tkinter

Uploaded by

jayshou2004
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

import random

from math import sin, cos, pi, log


from tkinter import *
import tkinter
CANVAS_WIDTH = 640
CANVAS_HEIGHT = 480
CANVAS_CENTER_X = CANVAS_WIDTH / 2
CANVAS_CENTER_Y = CANVAS_HEIGHT / 2
IMAGE_ENLARGE = 11
HEART_COLOR = "#ff2121"

def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):

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):

ratio_x = - beta * log([Link]())


ratio_y = - beta * log([Link]())
dx = ratio_x * (x - CANVAS_CENTER_X)
dy = ratio_y * (y - CANVAS_CENTER_Y)
return x - dx, y - dy

def shrink(x, y, ratio):

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):

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 = {}
[Link](2000)
self.random_halo = 1000
self.generate_frame = generate_frame
for frame in range(generate_frame):
[Link](frame)

def build(self, number):

for _ in range(number):
t = [Link](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 = [Link](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) + [Link](-1, 1)
dy = ratio * force * (y - CANVAS_CENTER_Y) + [Link](-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 = [Link](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 += [Link](-14, 14)
y += [Link](-14, 14)
size = [Link]((1, 2, 2))
all_points.append((x, y, size))

for x, y in self._points:
x, y = self.calc_position(x, y, ratio)
size = [Link](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 = [Link](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 = [Link](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)
[Link](160, draw, main, render_canvas, render_heart, render_frame + 1)

if __name__ == '__main__':
root = Tk()
canvas = Canvas(root, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)
[Link]()
heart = Heart()
draw(root, canvas, heart)

[Link]()

Common questions

Powered by AI

The build method seeds the heart shape by generating random points using the heart_function to define the initial true heart shape with 2000 points. It then disperses points around the edges and center to form edge and center diffusion points. This multi-layered point seeding lays the foundation for a dense and variable heart shape, allowing further manipulations to create the intricate and visually complex heart geometry .

The scatter_inside function introduces randomness to the heart shape by perturbing the x and y coordinates based on logarithmic scaling factors driven by random numbers. This function creates a diffuse effect around the edges of the heart, adding to the organic and less deterministic appearance of the graphical heart representation .

The Heart class employs polar equations, particularly by using the function heart_function(t), which calculates x and y coordinates using trigonometric equations: x = 16 * (sin(t) ** 3) and y = -(13 * cos(t) - 5 * cos(2 * t) - 2 * cos(3 * t) - cos(4 * t)). These functions define a heart shape and are scaled and translated to fit within the canvas by applying a shrink ratio and then adding center offsets .

Modifying the generate_frame parameter affects the dynamism and smoothness of the heart's animation. A higher generate_frame value results in more frames being precomputed and stored, leading to a smoother transition and animation cycle. Conversely, fewer frames may cause a choppy appearance, as fewer precomputed states are looped over, impacting how fluidly the heart appears to animate and transform .

The shrink function compresses the point positions towards the center using scaling influenced by the halo_radius. It applies a force inversely proportional to the distance from the center, multiplied by a ratio. This compression results in a tight clustering of points around the heart's shape, intensifying the halo effect by enhancing the density and brilliance of points within the calculated halo boundary .

The calc_position method calculates the updated positions of points by considering radial forces based on their distance from the center. It applies a ratio-scaled force inversely related to the distance from the canvas center, adding randomness for dynamic variance. This helps in creating a dynamic, pulsating effect in the graphical representation, making the heart appear more animated and alive .

The tkinter library provides essential tools for creating and managing the graphical user interface. It facilitates window creation with Tk(), enables drawing using Canvas for rendering the heart shape, and manages event loops to keep the application running and updating frames with mainloop(). Thus, tkinter serves as the backbone framework supporting all GUI operations in this application .

The heart_function employs trigonometric symmetries through the formulas for x and y coordinates, ensuring the heart is symmetrical about the vertical axis. The x = 16 * (sin(t) ** 3) expression produces identical values for t and -t due to the sine function's odd symmetry, while the composite cosine terms in the y-coordinate maintain symmetry through their even functions, together achieving a balanced heart shape .

The use of random.randint within the calc_position method introduces slight variations to the position calculations by adding or subtracting up to one unit. This randomness avoids uniformly rigid points, thereby contributing to the fluid and animated appearance of the heart. It creates a more lively and natural effect, essential for dynamic and visually engaging animations .

The render method is responsible for drawing the heart on the canvas for each frame. It iterates over all recorded points in all_points dictionary for the specified frame, creating rectangles on the canvas at each point's coordinates with varying sizes. This method directly translates the calculated positions and sizes into visible elements on the screen, leading to the visual formation of the heart .

You might also like