294 lines
9.2 KiB
Python
Executable File
294 lines
9.2 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Move Animation - Move objects along paths with various motion types.
|
|
|
|
Provides flexible movement primitives for objects along linear, arc, or custom paths.
|
|
"""
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
import math
|
|
|
|
sys.path.append(str(Path(__file__).parent.parent))
|
|
|
|
from core.gif_builder import GIFBuilder
|
|
from core.frame_composer import create_blank_frame, draw_circle, draw_emoji_enhanced
|
|
from core.easing import interpolate, calculate_arc_motion
|
|
|
|
|
|
def create_move_animation(
|
|
object_type: str = 'emoji',
|
|
object_data: dict | None = None,
|
|
start_pos: tuple[int, int] = (50, 240),
|
|
end_pos: tuple[int, int] = (430, 240),
|
|
num_frames: int = 30,
|
|
motion_type: str = 'linear', # 'linear', 'arc', 'bezier', 'circle', 'wave'
|
|
easing: str = 'ease_out',
|
|
motion_params: dict | None = None,
|
|
frame_width: int = 480,
|
|
frame_height: int = 480,
|
|
bg_color: tuple[int, int, int] = (255, 255, 255)
|
|
) -> list:
|
|
"""
|
|
Create frames showing object moving along a path.
|
|
|
|
Args:
|
|
object_type: 'circle', 'emoji', or 'custom'
|
|
object_data: Data for the object
|
|
start_pos: Starting (x, y) position
|
|
end_pos: Ending (x, y) position
|
|
num_frames: Number of frames
|
|
motion_type: Type of motion path
|
|
easing: Easing function name
|
|
motion_params: Additional parameters for motion (e.g., {'arc_height': 100})
|
|
frame_width: Frame width
|
|
frame_height: Frame height
|
|
bg_color: Background color
|
|
|
|
Returns:
|
|
List of frames
|
|
"""
|
|
frames = []
|
|
|
|
# Default object data
|
|
if object_data is None:
|
|
if object_type == 'circle':
|
|
object_data = {'radius': 30, 'color': (100, 150, 255)}
|
|
elif object_type == 'emoji':
|
|
object_data = {'emoji': '🚀', 'size': 60}
|
|
|
|
# Default motion params
|
|
if motion_params is None:
|
|
motion_params = {}
|
|
|
|
for i in range(num_frames):
|
|
frame = create_blank_frame(frame_width, frame_height, bg_color)
|
|
|
|
t = i / (num_frames - 1) if num_frames > 1 else 0
|
|
|
|
# Calculate position based on motion type
|
|
if motion_type == 'linear':
|
|
# Straight line with easing
|
|
x = interpolate(start_pos[0], end_pos[0], t, easing)
|
|
y = interpolate(start_pos[1], end_pos[1], t, easing)
|
|
|
|
elif motion_type == 'arc':
|
|
# Parabolic arc
|
|
arc_height = motion_params.get('arc_height', 100)
|
|
x, y = calculate_arc_motion(start_pos, end_pos, arc_height, t)
|
|
|
|
elif motion_type == 'circle':
|
|
# Circular motion around a center
|
|
center = motion_params.get('center', (frame_width // 2, frame_height // 2))
|
|
radius = motion_params.get('radius', 150)
|
|
start_angle = motion_params.get('start_angle', 0)
|
|
angle_range = motion_params.get('angle_range', 360) # Full circle
|
|
|
|
angle = start_angle + (angle_range * t)
|
|
angle_rad = math.radians(angle)
|
|
|
|
x = center[0] + radius * math.cos(angle_rad)
|
|
y = center[1] + radius * math.sin(angle_rad)
|
|
|
|
elif motion_type == 'wave':
|
|
# Move in straight line but add wave motion
|
|
wave_amplitude = motion_params.get('wave_amplitude', 50)
|
|
wave_frequency = motion_params.get('wave_frequency', 2)
|
|
|
|
# Base linear motion
|
|
base_x = interpolate(start_pos[0], end_pos[0], t, easing)
|
|
base_y = interpolate(start_pos[1], end_pos[1], t, easing)
|
|
|
|
# Add wave offset perpendicular to motion direction
|
|
dx = end_pos[0] - start_pos[0]
|
|
dy = end_pos[1] - start_pos[1]
|
|
length = math.sqrt(dx * dx + dy * dy)
|
|
|
|
if length > 0:
|
|
# Perpendicular direction
|
|
perp_x = -dy / length
|
|
perp_y = dx / length
|
|
|
|
# Wave offset
|
|
wave_offset = math.sin(t * wave_frequency * 2 * math.pi) * wave_amplitude
|
|
|
|
x = base_x + perp_x * wave_offset
|
|
y = base_y + perp_y * wave_offset
|
|
else:
|
|
x, y = base_x, base_y
|
|
|
|
elif motion_type == 'bezier':
|
|
# Quadratic bezier curve
|
|
control_point = motion_params.get('control_point', (
|
|
(start_pos[0] + end_pos[0]) // 2,
|
|
(start_pos[1] + end_pos[1]) // 2 - 100
|
|
))
|
|
|
|
# Quadratic Bezier formula: B(t) = (1-t)²P0 + 2(1-t)tP1 + t²P2
|
|
x = (1 - t) ** 2 * start_pos[0] + 2 * (1 - t) * t * control_point[0] + t ** 2 * end_pos[0]
|
|
y = (1 - t) ** 2 * start_pos[1] + 2 * (1 - t) * t * control_point[1] + t ** 2 * end_pos[1]
|
|
|
|
else:
|
|
# Default to linear
|
|
x = interpolate(start_pos[0], end_pos[0], t, easing)
|
|
y = interpolate(start_pos[1], end_pos[1], t, easing)
|
|
|
|
# Draw object at calculated position
|
|
x, y = int(x), int(y)
|
|
|
|
if object_type == 'circle':
|
|
draw_circle(
|
|
frame,
|
|
center=(x, y),
|
|
radius=object_data['radius'],
|
|
fill_color=object_data['color']
|
|
)
|
|
elif object_type == 'emoji':
|
|
draw_emoji_enhanced(
|
|
frame,
|
|
emoji=object_data['emoji'],
|
|
position=(x - object_data['size'] // 2, y - object_data['size'] // 2),
|
|
size=object_data['size'],
|
|
shadow=object_data.get('shadow', True)
|
|
)
|
|
|
|
frames.append(frame)
|
|
|
|
return frames
|
|
|
|
|
|
def create_path_from_points(points: list[tuple[int, int]],
|
|
num_frames: int = 60,
|
|
easing: str = 'ease_in_out') -> list[tuple[int, int]]:
|
|
"""
|
|
Create a smooth path through multiple points.
|
|
|
|
Args:
|
|
points: List of (x, y) waypoints
|
|
num_frames: Total number of frames
|
|
easing: Easing between points
|
|
|
|
Returns:
|
|
List of (x, y) positions for each frame
|
|
"""
|
|
if len(points) < 2:
|
|
return points * num_frames
|
|
|
|
path = []
|
|
frames_per_segment = num_frames // (len(points) - 1)
|
|
|
|
for i in range(len(points) - 1):
|
|
start = points[i]
|
|
end = points[i + 1]
|
|
|
|
# Last segment gets remaining frames
|
|
if i == len(points) - 2:
|
|
segment_frames = num_frames - len(path)
|
|
else:
|
|
segment_frames = frames_per_segment
|
|
|
|
for j in range(segment_frames):
|
|
t = j / segment_frames if segment_frames > 0 else 0
|
|
x = interpolate(start[0], end[0], t, easing)
|
|
y = interpolate(start[1], end[1], t, easing)
|
|
path.append((int(x), int(y)))
|
|
|
|
return path
|
|
|
|
|
|
def apply_trail_effect(frames: list, trail_length: int = 5,
|
|
fade_alpha: float = 0.3) -> list:
|
|
"""
|
|
Add motion trail effect to moving object.
|
|
|
|
Args:
|
|
frames: List of frames with moving object
|
|
trail_length: Number of previous frames to blend
|
|
fade_alpha: Opacity of trail frames
|
|
|
|
Returns:
|
|
List of frames with trail effect
|
|
"""
|
|
from PIL import Image, ImageChops
|
|
import numpy as np
|
|
|
|
trailed_frames = []
|
|
|
|
for i, frame in enumerate(frames):
|
|
# Start with current frame
|
|
result = frame.copy()
|
|
|
|
# Blend previous frames
|
|
for j in range(1, min(trail_length + 1, i + 1)):
|
|
prev_frame = frames[i - j]
|
|
|
|
# Calculate fade
|
|
alpha = fade_alpha ** j
|
|
|
|
# Blend
|
|
result_array = np.array(result, dtype=np.float32)
|
|
prev_array = np.array(prev_frame, dtype=np.float32)
|
|
|
|
blended = result_array * (1 - alpha) + prev_array * alpha
|
|
result = Image.fromarray(blended.astype(np.uint8))
|
|
|
|
trailed_frames.append(result)
|
|
|
|
return trailed_frames
|
|
|
|
|
|
# Example usage
|
|
if __name__ == '__main__':
|
|
print("Creating movement examples...")
|
|
|
|
# Example 1: Linear movement
|
|
builder = GIFBuilder(width=480, height=480, fps=20)
|
|
frames = create_move_animation(
|
|
object_type='emoji',
|
|
object_data={'emoji': '🚀', 'size': 60},
|
|
start_pos=(50, 240),
|
|
end_pos=(430, 240),
|
|
num_frames=30,
|
|
motion_type='linear',
|
|
easing='ease_out'
|
|
)
|
|
builder.add_frames(frames)
|
|
builder.save('move_linear.gif', num_colors=128)
|
|
|
|
# Example 2: Arc movement
|
|
builder.clear()
|
|
frames = create_move_animation(
|
|
object_type='emoji',
|
|
object_data={'emoji': '⚽', 'size': 60},
|
|
start_pos=(50, 350),
|
|
end_pos=(430, 350),
|
|
num_frames=30,
|
|
motion_type='arc',
|
|
motion_params={'arc_height': 150},
|
|
easing='linear'
|
|
)
|
|
builder.add_frames(frames)
|
|
builder.save('move_arc.gif', num_colors=128)
|
|
|
|
# Example 3: Circular movement
|
|
builder.clear()
|
|
frames = create_move_animation(
|
|
object_type='emoji',
|
|
object_data={'emoji': '🌍', 'size': 50},
|
|
start_pos=(0, 0), # Ignored for circle
|
|
end_pos=(0, 0), # Ignored for circle
|
|
num_frames=40,
|
|
motion_type='circle',
|
|
motion_params={
|
|
'center': (240, 240),
|
|
'radius': 120,
|
|
'start_angle': 0,
|
|
'angle_range': 360
|
|
},
|
|
easing='linear'
|
|
)
|
|
builder.add_frames(frames)
|
|
builder.save('move_circle.gif', num_colors=128)
|
|
|
|
print("Created movement examples!")
|