@caddis/cli 0.4.10 → 0.4.12

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

@@ -1,291 +0,0 @@
-#!/usr/bin/env python3
-"""
-Flip Animation - 3D-style card flip and rotation effects.
-
-Creates horizontal and vertical flips with perspective.
-"""
-
-import sys
-from pathlib import Path
-import math
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from PIL import Image
-from core.gif_builder import GIFBuilder
-from core.frame_composer import create_blank_frame, draw_emoji_enhanced
-from core.easing import interpolate
-
-
-def create_flip_animation(
-    object1_data: dict,
-    object2_data: dict | None = None,
-    num_frames: int = 30,
-    flip_axis: str = 'horizontal',  # 'horizontal', 'vertical'
-    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 3D-style flip animation.
-
-    Args:
-        object1_data: First object (front side)
-        object2_data: Second object (back side, None = same as front)
-        num_frames: Number of frames
-        flip_axis: Axis to flip around
-        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 = []
-
-    if object2_data is None:
-        object2_data = object1_data
-
-    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)
-
-        # Calculate rotation angle (0 to 180 degrees)
-        angle = interpolate(0, 180, t, easing)
-
-        # Determine which side is visible and calculate scale
-        if angle < 90:
-            # Front side visible
-            current_object = object1_data
-            scale_factor = math.cos(math.radians(angle))
-        else:
-            # Back side visible
-            current_object = object2_data
-            scale_factor = abs(math.cos(math.radians(angle)))
-
-        # Don't draw when edge-on (very thin)
-        if scale_factor < 0.05:
-            frames.append(frame)
-            continue
-
-        if object_type == 'emoji':
-            size = current_object['size']
-
-            # Create emoji on canvas
-            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
-            )
-
-            # Apply flip scaling
-            if flip_axis == 'horizontal':
-                # Scale horizontally for horizontal flip
-                new_width = max(1, int(canvas_size * scale_factor))
-                new_height = canvas_size
-            else:
-                # Scale vertically for vertical flip
-                new_width = canvas_size
-                new_height = max(1, int(canvas_size * scale_factor))
-
-            # Resize to simulate 3D rotation
-            emoji_scaled = emoji_canvas.resize((new_width, new_height), Image.LANCZOS)
-
-            # Position centered
-            paste_x = center_pos[0] - new_width // 2
-            paste_y = center_pos[1] - new_height // 2
-
-            # Composite onto frame
-            frame_rgba = frame.convert('RGBA')
-            frame_rgba.paste(emoji_scaled, (paste_x, paste_y), emoji_scaled)
-            frame = frame_rgba.convert('RGB')
-
-        elif object_type == 'text':
-            from core.typography import draw_text_with_outline
-
-            # Create text on canvas
-            text = current_object.get('text', 'FLIP')
-            font_size = current_object.get('font_size', 50)
-
-            canvas_size = max(frame_width, frame_height)
-            text_canvas = Image.new('RGBA', (canvas_size, canvas_size), (0, 0, 0, 0))
-
-            # Draw on RGB for text rendering
-            text_canvas_rgb = text_canvas.convert('RGB')
-            text_canvas_rgb.paste(bg_color, (0, 0, canvas_size, canvas_size))
-
-            draw_text_with_outline(
-                text_canvas_rgb,
-                text=text,
-                position=(canvas_size // 2, canvas_size // 2),
-                font_size=font_size,
-                text_color=current_object.get('text_color', (0, 0, 0)),
-                outline_color=current_object.get('outline_color', (255, 255, 255)),
-                outline_width=3,
-                centered=True
-            )
-
-            # 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 flip scaling
-            if flip_axis == 'horizontal':
-                new_width = max(1, int(canvas_size * scale_factor))
-                new_height = canvas_size
-            else:
-                new_width = canvas_size
-                new_height = max(1, int(canvas_size * scale_factor))
-
-            text_scaled = text_canvas.resize((new_width, new_height), Image.LANCZOS)
-
-            # Center and crop
-            if flip_axis == 'horizontal':
-                left = (new_width - frame_width) // 2 if new_width > frame_width else 0
-                top = (canvas_size - frame_height) // 2
-                paste_x = center_pos[0] - min(new_width, frame_width) // 2
-                paste_y = 0
-
-                text_cropped = text_scaled.crop((
-                    left,
-                    top,
-                    left + min(new_width, frame_width),
-                    top + frame_height
-                ))
-            else:
-                left = (canvas_size - frame_width) // 2
-                top = (new_height - frame_height) // 2 if new_height > frame_height else 0
-                paste_x = 0
-                paste_y = center_pos[1] - min(new_height, frame_height) // 2
-
-                text_cropped = text_scaled.crop((
-                    left,
-                    top,
-                    left + frame_width,
-                    top + min(new_height, frame_height)
-                ))
-
-            frame_rgba = frame.convert('RGBA')
-            frame_rgba.paste(text_cropped, (paste_x, paste_y), text_cropped)
-            frame = frame_rgba.convert('RGB')
-
-        frames.append(frame)
-
-    return frames
-
-
-def create_quick_flip(
-    emoji_front: str,
-    emoji_back: str,
-    num_frames: int = 20,
-    frame_size: int = 128
-) -> list[Image.Image]:
-    """
-    Create quick flip for emoji GIFs.
-
-    Args:
-        emoji_front: Front emoji
-        emoji_back: Back emoji
-        num_frames: Number of frames
-        frame_size: Frame size (square)
-
-    Returns:
-        List of frames
-    """
-    return create_flip_animation(
-        object1_data={'emoji': emoji_front, 'size': 80},
-        object2_data={'emoji': emoji_back, 'size': 80},
-        num_frames=num_frames,
-        flip_axis='horizontal',
-        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_nope_flip(
-    num_frames: int = 25,
-    frame_width: int = 480,
-    frame_height: int = 480
-) -> list[Image.Image]:
-    """
-    Create "nope" reaction flip (like flipping table).
-
-    Args:
-        num_frames: Number of frames
-        frame_width: Frame width
-        frame_height: Frame height
-
-    Returns:
-        List of frames
-    """
-    return create_flip_animation(
-        object1_data={'text': 'NOPE', 'font_size': 80, 'text_color': (255, 50, 50)},
-        object2_data={'text': 'NOPE', 'font_size': 80, 'text_color': (255, 50, 50)},
-        num_frames=num_frames,
-        flip_axis='horizontal',
-        easing='ease_out',
-        object_type='text',
-        frame_width=frame_width,
-        frame_height=frame_height,
-        bg_color=(255, 255, 255)
-    )
-
-
-# Example usage
-if __name__ == '__main__':
-    print("Creating flip animations...")
-
-    builder = GIFBuilder(width=480, height=480, fps=20)
-
-    # Example 1: Emoji flip
-    frames = create_flip_animation(
-        object1_data={'emoji': '😊', 'size': 120},
-        object2_data={'emoji': '😂', 'size': 120},
-        num_frames=30,
-        flip_axis='horizontal',
-        object_type='emoji'
-    )
-    builder.add_frames(frames)
-    builder.save('flip_emoji.gif', num_colors=128)
-
-    # Example 2: Text flip
-    builder.clear()
-    frames = create_flip_animation(
-        object1_data={'text': 'YES', 'font_size': 80, 'text_color': (100, 200, 100)},
-        object2_data={'text': 'NO', 'font_size': 80, 'text_color': (200, 100, 100)},
-        num_frames=30,
-        flip_axis='vertical',
-        object_type='text'
-    )
-    builder.add_frames(frames)
-    builder.save('flip_text.gif', num_colors=128)
-
-    # Example 3: Quick flip (emoji size)
-    builder = GIFBuilder(width=128, height=128, fps=15)
-    frames = create_quick_flip('👍', '👎', num_frames=20)
-    builder.add_frames(frames)
-    builder.save('flip_quick.gif', num_colors=48, optimize_for_emoji=True)
-
-    print("Created flip animations!")

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

@@ -1,211 +0,0 @@
-#!/usr/bin/env python3
-"""
-Kaleidoscope Effect - Create mirror/rotation effects.
-
-Apply kaleidoscope effects to frames or objects for psychedelic visuals.
-"""
-
-import sys
-from pathlib import Path
-import math
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from PIL import Image, ImageOps, ImageDraw
-import numpy as np
-
-
-def apply_kaleidoscope(frame: Image.Image, segments: int = 8,
-                       center: tuple[int, int] | None = None) -> Image.Image:
-    """
-    Apply kaleidoscope effect by mirroring/rotating frame sections.
-
-    Args:
-        frame: Input frame
-        segments: Number of mirror segments (4, 6, 8, 12 work well)
-        center: Center point for effect (None = frame center)
-
-    Returns:
-        Frame with kaleidoscope effect
-    """
-    width, height = frame.size
-
-    if center is None:
-        center = (width // 2, height // 2)
-
-    # Create output frame
-    output = Image.new('RGB', (width, height))
-
-    # Calculate angle per segment
-    angle_per_segment = 360 / segments
-
-    # For simplicity, we'll create a radial mirror effect
-    # A full implementation would rotate and mirror properly
-    # This is a simplified version that creates interesting patterns
-
-    # Convert to numpy for easier manipulation
-    frame_array = np.array(frame)
-    output_array = np.zeros_like(frame_array)
-
-    center_x, center_y = center
-
-    # Create wedge mask and mirror it
-    for y in range(height):
-        for x in range(width):
-            # Calculate angle from center
-            dx = x - center_x
-            dy = y - center_y
-
-            angle = (math.degrees(math.atan2(dy, dx)) + 180) % 360
-            distance = math.sqrt(dx * dx + dy * dy)
-
-            # Which segment does this pixel belong to?
-            segment = int(angle / angle_per_segment)
-
-            # Mirror angle within segment
-            segment_angle = angle % angle_per_segment
-            if segment % 2 == 1:  # Mirror every other segment
-                segment_angle = angle_per_segment - segment_angle
-
-            # Calculate source position
-            source_angle = segment_angle + (segment // 2) * angle_per_segment * 2
-            source_angle_rad = math.radians(source_angle - 180)
-
-            source_x = int(center_x + distance * math.cos(source_angle_rad))
-            source_y = int(center_y + distance * math.sin(source_angle_rad))
-
-            # Bounds check
-            if 0 <= source_x < width and 0 <= source_y < height:
-                output_array[y, x] = frame_array[source_y, source_x]
-            else:
-                output_array[y, x] = frame_array[y, x]
-
-    return Image.fromarray(output_array)
-
-
-def apply_simple_mirror(frame: Image.Image, mode: str = 'quad') -> Image.Image:
-    """
-    Apply simple mirror effect (faster than full kaleidoscope).
-
-    Args:
-        frame: Input frame
-        mode: 'horizontal', 'vertical', 'quad' (4-way), 'radial'
-
-    Returns:
-        Mirrored frame
-    """
-    width, height = frame.size
-    center_x, center_y = width // 2, height // 2
-
-    if mode == 'horizontal':
-        # Mirror left half to right
-        left_half = frame.crop((0, 0, center_x, height))
-        left_flipped = ImageOps.mirror(left_half)
-        result = frame.copy()
-        result.paste(left_flipped, (center_x, 0))
-        return result
-
-    elif mode == 'vertical':
-        # Mirror top half to bottom
-        top_half = frame.crop((0, 0, width, center_y))
-        top_flipped = ImageOps.flip(top_half)
-        result = frame.copy()
-        result.paste(top_flipped, (0, center_y))
-        return result
-
-    elif mode == 'quad':
-        # 4-way mirror (top-left quadrant mirrored to all)
-        quad = frame.crop((0, 0, center_x, center_y))
-
-        result = Image.new('RGB', (width, height))
-
-        # Top-left (original)
-        result.paste(quad, (0, 0))
-
-        # Top-right (horizontal mirror)
-        result.paste(ImageOps.mirror(quad), (center_x, 0))
-
-        # Bottom-left (vertical mirror)
-        result.paste(ImageOps.flip(quad), (0, center_y))
-
-        # Bottom-right (both mirrors)
-        result.paste(ImageOps.flip(ImageOps.mirror(quad)), (center_x, center_y))
-
-        return result
-
-    else:
-        return frame
-
-
-def create_kaleidoscope_animation(
-    base_frame: Image.Image | None = None,
-    num_frames: int = 30,
-    segments: int = 8,
-    rotation_speed: float = 1.0,
-    width: int = 480,
-    height: int = 480
-) -> list[Image.Image]:
-    """
-    Create animated kaleidoscope effect.
-
-    Args:
-        base_frame: Frame to apply effect to (or None for demo pattern)
-        num_frames: Number of frames
-        segments: Kaleidoscope segments
-        rotation_speed: How fast pattern rotates (0.5-2.0)
-        width: Frame width if generating demo
-        height: Frame height if generating demo
-
-    Returns:
-        List of frames with kaleidoscope effect
-    """
-    frames = []
-
-    # Create demo pattern if no base frame
-    if base_frame is None:
-        base_frame = Image.new('RGB', (width, height), (255, 255, 255))
-        draw = ImageDraw.Draw(base_frame)
-
-        # Draw some colored shapes
-        from core.color_palettes import get_palette
-        palette = get_palette('vibrant')
-
-        colors = [palette['primary'], palette['secondary'], palette['accent']]
-
-        for i, color in enumerate(colors):
-            x = width // 2 + int(100 * math.cos(i * 2 * math.pi / 3))
-            y = height // 2 + int(100 * math.sin(i * 2 * math.pi / 3))
-            draw.ellipse([x - 40, y - 40, x + 40, y + 40], fill=color)
-
-    # Rotate base frame and apply kaleidoscope
-    for i in range(num_frames):
-        angle = (i / num_frames) * 360 * rotation_speed
-
-        # Rotate base frame
-        rotated = base_frame.rotate(angle, resample=Image.BICUBIC)
-
-        # Apply kaleidoscope
-        kaleido_frame = apply_kaleidoscope(rotated, segments=segments)
-
-        frames.append(kaleido_frame)
-
-    return frames
-
-
-# Example usage
-if __name__ == '__main__':
-    from core.gif_builder import GIFBuilder
-
-    print("Creating kaleidoscope GIF...")
-
-    builder = GIFBuilder(width=480, height=480, fps=20)
-
-    # Create kaleidoscope animation
-    frames = create_kaleidoscope_animation(
-        num_frames=40,
-        segments=8,
-        rotation_speed=0.5
-    )
-
-    builder.add_frames(frames)
-    builder.save('kaleidoscope_test.gif', num_colors=128)