zhongwei/gh-cam10001110101-claude-skills-base-example-skills
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-29 18:03:29 +08:00
commit 374eecc4f3
158 changed files with 18863 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

293
skills/slack-gif-creator/templates/move.py Normal file
View File

@@ -0,0 +1,293 @@
#!/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!")