@caddis/cli 0.4.10 → 0.4.12

package/bundles/antigravity-plugin-extras/skills/slack-gif-creator/templates/explode.py

@@ -1,331 +0,0 @@
-#!/usr/bin/env python3
-"""
-Explode Animation - Break objects into pieces that fly outward.
-
-Creates explosion, shatter, and particle burst effects.
-"""
-
-import sys
-from pathlib import Path
-import math
-import random
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from PIL import Image, ImageDraw
-import numpy as np
-from core.gif_builder import GIFBuilder
-from core.frame_composer import create_blank_frame, draw_emoji_enhanced
-from core.visual_effects import ParticleSystem
-from core.easing import interpolate
-
-
-def create_explode_animation(
-    object_type: str = 'emoji',
-    object_data: dict | None = None,
-    num_frames: int = 30,
-    explode_type: str = 'burst',  # 'burst', 'shatter', 'dissolve', 'implode'
-    num_pieces: int = 20,
-    explosion_speed: float = 5.0,
-    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 explosion animation.
-
-    Args:
-        object_type: 'emoji', 'circle', 'text'
-        object_data: Object configuration
-        num_frames: Number of frames
-        explode_type: Type of explosion
-        num_pieces: Number of pieces/particles
-        explosion_speed: Speed of explosion
-        center_pos: Center position
-        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 == 'emoji':
-            object_data = {'emoji': '💣', 'size': 100}
-
-    # Generate pieces/particles
-    pieces = []
-    for _ in range(num_pieces):
-        angle = random.uniform(0, 2 * math.pi)
-        speed = random.uniform(explosion_speed * 0.5, explosion_speed * 1.5)
-        vx = math.cos(angle) * speed
-        vy = math.sin(angle) * speed
-        size = random.randint(3, 12)
-        color = (
-            random.randint(100, 255),
-            random.randint(100, 255),
-            random.randint(100, 255)
-        )
-        rotation_speed = random.uniform(-20, 20)
-
-        pieces.append({
-            'vx': vx,
-            'vy': vy,
-            'size': size,
-            'color': color,
-            'rotation': 0,
-            'rotation_speed': rotation_speed
-        })
-
-    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)
-        draw = ImageDraw.Draw(frame)
-
-        if explode_type == 'burst':
-            # Show object at start, then explode
-            if t < 0.2:
-                # Object still intact
-                scale = interpolate(1.0, 1.2, t / 0.2, 'ease_out')
-                if object_type == 'emoji':
-                    size = int(object_data['size'] * scale)
-                    draw_emoji_enhanced(
-                        frame,
-                        emoji=object_data['emoji'],
-                        position=(center_pos[0] - size // 2, center_pos[1] - size // 2),
-                        size=size,
-                        shadow=False
-                    )
-            else:
-                # Exploded - draw pieces
-                explosion_t = (t - 0.2) / 0.8
-                for piece in pieces:
-                    # Update position
-                    x = center_pos[0] + piece['vx'] * explosion_t * 50
-                    y = center_pos[1] + piece['vy'] * explosion_t * 50 + 0.5 * 300 * explosion_t ** 2  # Gravity
-
-                    # Fade out
-                    alpha = 1.0 - explosion_t
-                    if alpha > 0:
-                        color = tuple(int(c * alpha) for c in piece['color'])
-                        size = int(piece['size'] * (1 - explosion_t * 0.5))
-
-                        draw.ellipse(
-                            [x - size, y - size, x + size, y + size],
-                            fill=color
-                        )
-
-        elif explode_type == 'shatter':
-            # Break into geometric pieces
-            if t < 0.15:
-                # Object intact
-                if object_type == 'emoji':
-                    draw_emoji_enhanced(
-                        frame,
-                        emoji=object_data['emoji'],
-                        position=(center_pos[0] - object_data['size'] // 2,
-                                center_pos[1] - object_data['size'] // 2),
-                        size=object_data['size'],
-                        shadow=False
-                    )
-            else:
-                # Shattered
-                shatter_t = (t - 0.15) / 0.85
-
-                # Draw triangular shards
-                for piece in pieces[:min(10, len(pieces))]:
-                    x = center_pos[0] + piece['vx'] * shatter_t * 30
-                    y = center_pos[1] + piece['vy'] * shatter_t * 30 + 0.5 * 200 * shatter_t ** 2
-
-                    # Update rotation
-                    rotation = piece['rotation_speed'] * shatter_t * 100
-
-                    # Draw triangle shard
-                    shard_size = piece['size'] * 2
-                    points = []
-                    for j in range(3):
-                        angle = (rotation + j * 120) * math.pi / 180
-                        px = x + shard_size * math.cos(angle)
-                        py = y + shard_size * math.sin(angle)
-                        points.append((px, py))
-
-                    alpha = 1.0 - shatter_t
-                    if alpha > 0:
-                        color = tuple(int(c * alpha) for c in piece['color'])
-                        draw.polygon(points, fill=color)
-
-        elif explode_type == 'dissolve':
-            # Dissolve into particles
-            dissolve_scale = interpolate(1.0, 0.0, t, 'ease_in')
-
-            if dissolve_scale > 0.1:
-                # Draw fading object
-                if object_type == 'emoji':
-                    size = int(object_data['size'] * dissolve_scale)
-                    size = max(12, size)
-
-                    emoji_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
-                    draw_emoji_enhanced(
-                        emoji_canvas,
-                        emoji=object_data['emoji'],
-                        position=(center_pos[0] - size // 2, center_pos[1] - size // 2),
-                        size=size,
-                        shadow=False
-                    )
-
-                    # Apply opacity
-                    from templates.fade import apply_opacity
-                    emoji_canvas = apply_opacity(emoji_canvas, dissolve_scale)
-
-                    frame_rgba = frame.convert('RGBA')
-                    frame = Image.alpha_composite(frame_rgba, emoji_canvas)
-                    frame = frame.convert('RGB')
-                    draw = ImageDraw.Draw(frame)
-
-            # Draw outward-moving particles
-            for piece in pieces:
-                x = center_pos[0] + piece['vx'] * t * 40
-                y = center_pos[1] + piece['vy'] * t * 40
-
-                alpha = 1.0 - t
-                if alpha > 0:
-                    color = tuple(int(c * alpha) for c in piece['color'])
-                    size = int(piece['size'] * (1 - t * 0.5))
-                    draw.ellipse(
-                        [x - size, y - size, x + size, y + size],
-                        fill=color
-                    )
-
-        elif explode_type == 'implode':
-            # Reverse explosion - pieces fly inward
-            if t < 0.7:
-                # Pieces converging
-                implode_t = 1.0 - (t / 0.7)
-                for piece in pieces:
-                    x = center_pos[0] + piece['vx'] * implode_t * 50
-                    y = center_pos[1] + piece['vy'] * implode_t * 50
-
-                    alpha = 1.0 - (1.0 - implode_t) * 0.5
-                    color = tuple(int(c * alpha) for c in piece['color'])
-                    size = int(piece['size'] * alpha)
-
-                    draw.ellipse(
-                        [x - size, y - size, x + size, y + size],
-                        fill=color
-                    )
-            else:
-                # Object reforms
-                reform_t = (t - 0.7) / 0.3
-                scale = interpolate(0.5, 1.0, reform_t, 'elastic_out')
-
-                if object_type == 'emoji':
-                    size = int(object_data['size'] * scale)
-                    draw_emoji_enhanced(
-                        frame,
-                        emoji=object_data['emoji'],
-                        position=(center_pos[0] - size // 2, center_pos[1] - size // 2),
-                        size=size,
-                        shadow=False
-                    )
-
-        frames.append(frame)
-
-    return frames
-
-
-def create_particle_burst(
-    num_frames: int = 25,
-    particle_count: int = 30,
-    center_pos: tuple[int, int] = (240, 240),
-    colors: list[tuple[int, int, int]] | None = None,
-    frame_width: int = 480,
-    frame_height: int = 480,
-    bg_color: tuple[int, int, int] = (255, 255, 255)
-) -> list[Image.Image]:
-    """
-    Create simple particle burst effect.
-
-    Args:
-        num_frames: Number of frames
-        particle_count: Number of particles
-        center_pos: Burst center
-        colors: Particle colors (None for random)
-        frame_width: Frame width
-        frame_height: Frame height
-        bg_color: Background color
-
-    Returns:
-        List of frames
-    """
-    particles = ParticleSystem()
-
-    # Emit particles
-    if colors is None:
-        from core.color_palettes import get_palette
-        palette = get_palette('vibrant')
-        colors = [palette['primary'], palette['secondary'], palette['accent']]
-
-    for _ in range(particle_count):
-        color = random.choice(colors)
-        particles.emit(
-            center_pos[0], center_pos[1],
-            count=1,
-            speed=random.uniform(3, 8),
-            color=color,
-            lifetime=random.uniform(20, 30),
-            size=random.randint(3, 8),
-            shape='star'
-        )
-
-    frames = []
-    for _ in range(num_frames):
-        frame = create_blank_frame(frame_width, frame_height, bg_color)
-
-        particles.update()
-        particles.render(frame)
-
-        frames.append(frame)
-
-    return frames
-
-
-# Example usage
-if __name__ == '__main__':
-    print("Creating explode animations...")
-
-    builder = GIFBuilder(width=480, height=480, fps=20)
-
-    # Example 1: Burst
-    frames = create_explode_animation(
-        object_type='emoji',
-        object_data={'emoji': '💣', 'size': 100},
-        num_frames=30,
-        explode_type='burst',
-        num_pieces=25
-    )
-    builder.add_frames(frames)
-    builder.save('explode_burst.gif', num_colors=128)
-
-    # Example 2: Shatter
-    builder.clear()
-    frames = create_explode_animation(
-        object_type='emoji',
-        object_data={'emoji': '🪟', 'size': 100},
-        num_frames=30,
-        explode_type='shatter',
-        num_pieces=12
-    )
-    builder.add_frames(frames)
-    builder.save('explode_shatter.gif', num_colors=128)
-
-    # Example 3: Particle burst
-    builder.clear()
-    frames = create_particle_burst(num_frames=25, particle_count=40)
-    builder.add_frames(frames)
-    builder.save('explode_particles.gif', num_colors=128)
-
-    print("Created explode animations!")

package/bundles/antigravity-plugin-extras/skills/slack-gif-creator/templates/fade.py

@@ -1,329 +0,0 @@
-#!/usr/bin/env python3
-"""
-Fade Animation - Fade in, fade out, and crossfade effects.
-
-Creates smooth opacity transitions for appearing, disappearing, and transitioning.
-"""
-
-import sys
-from pathlib import Path
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from PIL import Image, ImageDraw
-import numpy as np
-from core.gif_builder import GIFBuilder
-from core.frame_composer import create_blank_frame, draw_emoji_enhanced
-from core.easing import interpolate
-
-
-def create_fade_animation(
-    object_type: str = 'emoji',
-    object_data: dict | None = None,
-    num_frames: int = 30,
-    fade_type: str = 'in',  # 'in', 'out', 'in_out', 'blink'
-    easing: str = 'ease_in_out',
-    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 fade animation.
-
-    Args:
-        object_type: 'emoji', 'text', 'image'
-        object_data: Object configuration
-        num_frames: Number of frames
-        fade_type: Type of fade effect
-        easing: Easing function
-        center_pos: Center position
-        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 == 'emoji':
-            object_data = {'emoji': '✨', 'size': 100}
-
-    for i in range(num_frames):
-        t = i / (num_frames - 1) if num_frames > 1 else 0
-
-        # Calculate opacity based on fade type
-        if fade_type == 'in':
-            opacity = interpolate(0, 1, t, easing)
-        elif fade_type == 'out':
-            opacity = interpolate(1, 0, t, easing)
-        elif fade_type == 'in_out':
-            if t < 0.5:
-                opacity = interpolate(0, 1, t * 2, easing)
-            else:
-                opacity = interpolate(1, 0, (t - 0.5) * 2, easing)
-        elif fade_type == 'blink':
-            # Quick fade out and back in
-            if t < 0.2:
-                opacity = interpolate(1, 0, t / 0.2, 'ease_in')
-            elif t < 0.4:
-                opacity = interpolate(0, 1, (t - 0.2) / 0.2, 'ease_out')
-            else:
-                opacity = 1.0
-        else:
-            opacity = interpolate(0, 1, t, easing)
-
-        # Create background
-        frame_bg = create_blank_frame(frame_width, frame_height, bg_color)
-
-        # Create object layer with transparency
-        if object_type == 'emoji':
-            # Create RGBA canvas for emoji
-            emoji_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
-            emoji_size = object_data['size']
-            draw_emoji_enhanced(
-                emoji_canvas,
-                emoji=object_data['emoji'],
-                position=(center_pos[0] - emoji_size // 2, center_pos[1] - emoji_size // 2),
-                size=emoji_size,
-                shadow=object_data.get('shadow', False)
-            )
-
-            # Apply opacity
-            emoji_canvas = apply_opacity(emoji_canvas, opacity)
-
-            # Composite onto background
-            frame_bg_rgba = frame_bg.convert('RGBA')
-            frame = Image.alpha_composite(frame_bg_rgba, emoji_canvas)
-            frame = frame.convert('RGB')
-
-        elif object_type == 'text':
-            from core.typography import draw_text_with_outline
-
-            # Create text on separate layer
-            text_canvas = Image.new('RGBA', (frame_width, frame_height), (0, 0, 0, 0))
-            text_canvas_rgb = text_canvas.convert('RGB')
-            text_canvas_rgb.paste(bg_color, (0, 0, frame_width, frame_height))
-
-            draw_text_with_outline(
-                text_canvas_rgb,
-                text=object_data.get('text', 'FADE'),
-                position=center_pos,
-                font_size=object_data.get('font_size', 60),
-                text_color=object_data.get('text_color', (0, 0, 0)),
-                outline_color=object_data.get('outline_color', (255, 255, 255)),
-                outline_width=3,
-                centered=True
-            )
-
-            # Convert to RGBA and make background transparent
-            text_canvas = text_canvas_rgb.convert('RGBA')
-            data = text_canvas.getdata()
-            new_data = []
-            for item in data:
-                if item[:3] == bg_color:
-                    new_data.append((255, 255, 255, 0))
-                else:
-                    new_data.append(item)
-            text_canvas.putdata(new_data)
-
-            # Apply opacity
-            text_canvas = apply_opacity(text_canvas, opacity)
-
-            # Composite
-            frame_bg_rgba = frame_bg.convert('RGBA')
-            frame = Image.alpha_composite(frame_bg_rgba, text_canvas)
-            frame = frame.convert('RGB')
-
-        else:
-            frame = frame_bg
-
-        frames.append(frame)
-
-    return frames
-
-
-def apply_opacity(image: Image.Image, opacity: float) -> Image.Image:
-    """
-    Apply opacity to an RGBA image.
-
-    Args:
-        image: RGBA image
-        opacity: Opacity value (0.0 to 1.0)
-
-    Returns:
-        Image with adjusted opacity
-    """
-    if image.mode != 'RGBA':
-        image = image.convert('RGBA')
-
-    # Get alpha channel
-    r, g, b, a = image.split()
-
-    # Multiply alpha by opacity
-    a_array = np.array(a, dtype=np.float32)
-    a_array = a_array * opacity
-    a = Image.fromarray(a_array.astype(np.uint8))
-
-    # Merge back
-    return Image.merge('RGBA', (r, g, b, a))
-
-
-def create_crossfade(
-    object1_data: dict,
-    object2_data: dict,
-    num_frames: int = 30,
-    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]:
-    """
-    Crossfade between two objects.
-
-    Args:
-        object1_data: First object configuration
-        object2_data: Second object configuration
-        num_frames: Number of frames
-        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
-
-        # Calculate opacities
-        opacity1 = interpolate(1, 0, t, easing)
-        opacity2 = interpolate(0, 1, t, easing)
-
-        # Create background
-        frame = create_blank_frame(frame_width, frame_height, bg_color)
-
-        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
-            )
-            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')
-
-        frames.append(frame)
-
-    return frames
-
-
-def create_fade_to_color(
-    start_color: tuple[int, int, int],
-    end_color: tuple[int, int, int],
-    num_frames: int = 20,
-    easing: str = 'linear',
-    frame_width: int = 480,
-    frame_height: int = 480
-) -> list[Image.Image]:
-    """
-    Fade from one solid color to another.
-
-    Args:
-        start_color: Starting RGB color
-        end_color: Ending RGB color
-        num_frames: Number of frames
-        easing: Easing function
-        frame_width: Frame width
-        frame_height: Frame height
-
-    Returns:
-        List of frames
-    """
-    frames = []
-
-    for i in range(num_frames):
-        t = i / (num_frames - 1) if num_frames > 1 else 0
-
-        # Interpolate each color channel
-        r = int(interpolate(start_color[0], end_color[0], t, easing))
-        g = int(interpolate(start_color[1], end_color[1], t, easing))
-        b = int(interpolate(start_color[2], end_color[2], t, easing))
-
-        color = (r, g, b)
-        frame = create_blank_frame(frame_width, frame_height, color)
-        frames.append(frame)
-
-    return frames
-
-
-# Example usage
-if __name__ == '__main__':
-    print("Creating fade animations...")
-
-    builder = GIFBuilder(width=480, height=480, fps=20)
-
-    # Example 1: Fade in
-    frames = create_fade_animation(
-        object_type='emoji',
-        object_data={'emoji': '✨', 'size': 120},
-        num_frames=30,
-        fade_type='in',
-        easing='ease_out'
-    )
-    builder.add_frames(frames)
-    builder.save('fade_in.gif', num_colors=128)
-
-    # Example 2: Crossfade
-    builder.clear()
-    frames = create_crossfade(
-        object1_data={'emoji': '😊', 'size': 100},
-        object2_data={'emoji': '😂', 'size': 100},
-        num_frames=30,
-        object_type='emoji'
-    )
-    builder.add_frames(frames)
-    builder.save('fade_crossfade.gif', num_colors=128)
-
-    # Example 3: Blink
-    builder.clear()
-    frames = create_fade_animation(
-        object_type='emoji',
-        object_data={'emoji': '👀', 'size': 100},
-        num_frames=20,
-        fade_type='blink'
-    )
-    builder.add_frames(frames)
-    builder.save('fade_blink.gif', num_colors=128)
-
-    print("Created fade animations!")