@amrhas82/agentic-kit 1.0.0

package/skills/slack-gif-creator/templates/flip.py

@@ -0,0 +1,291 @@
+#!/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/skills/slack-gif-creator/templates/kaleidoscope.py

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