@amrhas82/agentic-kit 1.7.0 → 1.7.5

package/packages/claude/skills/slack-gif-creator/templates/morph.py

@@ -1,329 +0,0 @@
-#!/usr/bin/env python3
-"""
-Morph Animation - Transform between different emojis or shapes.
-
-Creates smooth transitions and transformations.
-"""
-
-import sys
-from pathlib import Path
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from PIL import Image
-import numpy as np
-from core.gif_builder import GIFBuilder
-from core.frame_composer import create_blank_frame, draw_emoji_enhanced, draw_circle
-from core.easing import interpolate
-
-
-def create_morph_animation(
-    object1_data: dict,
-    object2_data: dict,
-    num_frames: int = 30,
-    morph_type: str = 'crossfade',  # 'crossfade', 'scale', 'spin_morph'
-    easing: str = 'ease_in_out',
-    object_type: str = 'emoji',
-    center_pos: tuple[int, int] = (240, 240),
-    frame_width: int = 480,
-    frame_height: int = 480,
-    bg_color: tuple[int, int, int] = (255, 255, 255)
-) -> list[Image.Image]:
-    """
-    Create morphing animation between two objects.
-
-    Args:
-        object1_data: First object configuration
-        object2_data: Second object configuration
-        num_frames: Number of frames
-        morph_type: Type of morph effect
-        easing: Easing function
-        object_type: Type of objects
-        center_pos: Center position
-        frame_width: Frame width
-        frame_height: Frame height
-        bg_color: Background color
-
-    Returns:
-        List of frames
-    """
-    frames = []
-
-    for i in range(num_frames):
-        t = i / (num_frames - 1) if num_frames > 1 else 0
-        frame = create_blank_frame(frame_width, frame_height, bg_color)
-
-        if morph_type == 'crossfade':
-            # Simple crossfade between two objects
-            opacity1 = interpolate(1, 0, t, easing)
-            opacity2 = interpolate(0, 1, t, easing)
-
-            if object_type == 'emoji':
-                # Create first emoji
-                emoji1_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
-                size1 = object1_data['size']
-                draw_emoji_enhanced(
-                    emoji1_canvas,
-                    emoji=object1_data['emoji'],
-                    position=(center_pos[0] - size1 // 2, center_pos[1] - size1 // 2),
-                    size=size1,
-                    shadow=False
-                )
-
-                # Apply opacity
-                from templates.fade import apply_opacity
-                emoji1_canvas = apply_opacity(emoji1_canvas, opacity1)
-
-                # Create second emoji
-                emoji2_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
-                size2 = object2_data['size']
-                draw_emoji_enhanced(
-                    emoji2_canvas,
-                    emoji=object2_data['emoji'],
-                    position=(center_pos[0] - size2 // 2, center_pos[1] - size2 // 2),
-                    size=size2,
-                    shadow=False
-                )
-
-                emoji2_canvas = apply_opacity(emoji2_canvas, opacity2)
-
-                # Composite both
-                frame_rgba = frame.convert('RGBA')
-                frame_rgba = Image.alpha_composite(frame_rgba, emoji1_canvas)
-                frame_rgba = Image.alpha_composite(frame_rgba, emoji2_canvas)
-                frame = frame_rgba.convert('RGB')
-
-            elif object_type == 'circle':
-                # Morph between two circles
-                radius1 = object1_data['radius']
-                radius2 = object2_data['radius']
-                color1 = object1_data['color']
-                color2 = object2_data['color']
-
-                # Interpolate properties
-                current_radius = int(interpolate(radius1, radius2, t, easing))
-                current_color = tuple(
-                    int(interpolate(color1[i], color2[i], t, easing))
-                    for i in range(3)
-                )
-
-                draw_circle(frame, center_pos, current_radius, fill_color=current_color)
-
-        elif morph_type == 'scale':
-            # First object scales down as second scales up
-            if object_type == 'emoji':
-                scale1 = interpolate(1.0, 0.0, t, easing)
-                scale2 = interpolate(0.0, 1.0, t, easing)
-
-                # Draw first emoji (shrinking)
-                if scale1 > 0.05:
-                    size1 = int(object1_data['size'] * scale1)
-                    size1 = max(12, size1)
-                    emoji1_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
-                    draw_emoji_enhanced(
-                        emoji1_canvas,
-                        emoji=object1_data['emoji'],
-                        position=(center_pos[0] - size1 // 2, center_pos[1] - size1 // 2),
-                        size=size1,
-                        shadow=False
-                    )
-
-                    frame_rgba = frame.convert('RGBA')
-                    frame = Image.alpha_composite(frame_rgba, emoji1_canvas)
-                    frame = frame.convert('RGB')
-
-                # Draw second emoji (growing)
-                if scale2 > 0.05:
-                    size2 = int(object2_data['size'] * scale2)
-                    size2 = max(12, size2)
-                    emoji2_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
-                    draw_emoji_enhanced(
-                        emoji2_canvas,
-                        emoji=object2_data['emoji'],
-                        position=(center_pos[0] - size2 // 2, center_pos[1] - size2 // 2),
-                        size=size2,
-                        shadow=False
-                    )
-
-                    frame_rgba = frame.convert('RGBA')
-                    frame = Image.alpha_composite(frame_rgba, emoji2_canvas)
-                    frame = frame.convert('RGB')
-
-        elif morph_type == 'spin_morph':
-            # Spin while morphing (flip-like)
-            import math
-
-            # Calculate rotation (0 to 180 degrees)
-            angle = interpolate(0, 180, t, easing)
-            scale_factor = abs(math.cos(math.radians(angle)))
-
-            # Determine which object to show
-            if angle < 90:
-                current_object = object1_data
-            else:
-                current_object = object2_data
-
-            # Skip when edge-on
-            if scale_factor < 0.05:
-                frames.append(frame)
-                continue
-
-            if object_type == 'emoji':
-                size = current_object['size']
-                canvas_size = size * 2
-                emoji_canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))
-
-                draw_emoji_enhanced(
-                    emoji_canvas,
-                    emoji=current_object['emoji'],
-                    position=(canvas_size // 2 - size // 2, canvas_size // 2 - size // 2),
-                    size=size,
-                    shadow=False
-                )
-
-                # Scale horizontally for spin effect
-                new_width = max(1, int(canvas_size * scale_factor))
-                emoji_scaled = emoji_canvas.resize((new_width, canvas_size), Image.LANCZOS)
-
-                paste_x = center_pos[0] - new_width // 2
-                paste_y = center_pos[1] - canvas_size // 2
-
-                frame_rgba = frame.convert('RGBA')
-                frame_rgba.paste(emoji_scaled, (paste_x, paste_y), emoji_scaled)
-                frame = frame_rgba.convert('RGB')
-
-        frames.append(frame)
-
-    return frames
-
-
-def create_reaction_morph(
-    emoji_start: str,
-    emoji_end: str,
-    num_frames: int = 20,
-    frame_size: int = 128
-) -> list[Image.Image]:
-    """
-    Create quick emoji reaction morph (for emoji GIFs).
-
-    Args:
-        emoji_start: Starting emoji
-        emoji_end: Ending emoji
-        num_frames: Number of frames
-        frame_size: Frame size (square)
-
-    Returns:
-        List of frames
-    """
-    return create_morph_animation(
-        object1_data={'emoji': emoji_start, 'size': 80},
-        object2_data={'emoji': emoji_end, 'size': 80},
-        num_frames=num_frames,
-        morph_type='crossfade',
-        easing='ease_in_out',
-        object_type='emoji',
-        center_pos=(frame_size // 2, frame_size // 2),
-        frame_width=frame_size,
-        frame_height=frame_size,
-        bg_color=(255, 255, 255)
-    )
-
-
-def create_shape_morph(
-    shapes: list[dict],
-    num_frames: int = 60,
-    frames_per_shape: int = 20,
-    frame_width: int = 480,
-    frame_height: int = 480,
-    bg_color: tuple[int, int, int] = (255, 255, 255)
-) -> list[Image.Image]:
-    """
-    Morph through a sequence of shapes.
-
-    Args:
-        shapes: List of shape dicts with 'radius' and 'color'
-        num_frames: Total number of frames
-        frames_per_shape: Frames to spend on each morph
-        frame_width: Frame width
-        frame_height: Frame height
-        bg_color: Background color
-
-    Returns:
-        List of frames
-    """
-    frames = []
-    center = (frame_width // 2, frame_height // 2)
-
-    for i in range(num_frames):
-        # Determine which shapes we're morphing between
-        cycle_progress = (i % (frames_per_shape * len(shapes))) / frames_per_shape
-        shape_idx = int(cycle_progress) % len(shapes)
-        next_shape_idx = (shape_idx + 1) % len(shapes)
-
-        # Progress between these two shapes
-        t = cycle_progress - shape_idx
-
-        shape1 = shapes[shape_idx]
-        shape2 = shapes[next_shape_idx]
-
-        # Interpolate properties
-        radius = int(interpolate(shape1['radius'], shape2['radius'], t, 'ease_in_out'))
-        color = tuple(
-            int(interpolate(shape1['color'][j], shape2['color'][j], t, 'ease_in_out'))
-            for j in range(3)
-        )
-
-        # Draw frame
-        frame = create_blank_frame(frame_width, frame_height, bg_color)
-        draw_circle(frame, center, radius, fill_color=color)
-
-        frames.append(frame)
-
-    return frames
-
-
-# Example usage
-if __name__ == '__main__':
-    print("Creating morph animations...")
-
-    builder = GIFBuilder(width=480, height=480, fps=20)
-
-    # Example 1: Crossfade morph
-    frames = create_morph_animation(
-        object1_data={'emoji': '😊', 'size': 100},
-        object2_data={'emoji': '😂', 'size': 100},
-        num_frames=30,
-        morph_type='crossfade',
-        object_type='emoji'
-    )
-    builder.add_frames(frames)
-    builder.save('morph_crossfade.gif', num_colors=128)
-
-    # Example 2: Scale morph
-    builder.clear()
-    frames = create_morph_animation(
-        object1_data={'emoji': '🌙', 'size': 100},
-        object2_data={'emoji': '☀️', 'size': 100},
-        num_frames=40,
-        morph_type='scale',
-        object_type='emoji'
-    )
-    builder.add_frames(frames)
-    builder.save('morph_scale.gif', num_colors=128)
-
-    # Example 3: Shape morph cycle
-    builder.clear()
-    from core.color_palettes import get_palette
-    palette = get_palette('vibrant')
-
-    shapes = [
-        {'radius': 60, 'color': palette['primary']},
-        {'radius': 80, 'color': palette['secondary']},
-        {'radius': 50, 'color': palette['accent']},
-        {'radius': 70, 'color': palette['success']}
-    ]
-    frames = create_shape_morph(shapes, num_frames=80, frames_per_shape=20)
-    builder.add_frames(frames)
-    builder.save('morph_shapes.gif', num_colors=64)
-
-    print("Created morph animations!")

package/packages/claude/skills/slack-gif-creator/templates/move.py

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