Skip to content

davepoon/buildwithclaude / plugins/all-skills/skills/slack-gif-creator

slack-gif-creator

Verified

Toolkit for creating animated GIFs optimized for Slack, with validators for size constraints and composable animation primitives. This skill applies when users request animated GIFs or emoji animations for Slack from descriptions like "make me a GIF for Slack of X doing Y".

FileKindSize
LICENSE.txtmarkdown11.1 KB
SKILL.mdskill md16.8 KB
core/color_palettes.pyexecutablescript8.5 KB
core/easing.pyexecutablescript6.1 KB
core/frame_composer.pyexecutablescript14.1 KB
core/gif_builder.pyexecutablescript9.3 KB
core/typography.pyexecutablescript10.5 KB
core/validators.pyexecutablescript8.0 KB
core/visual_effects.pyexecutablescript14.5 KB
requirements.txtmanifest66 B
templates/bounce.pyexecutablescript3.0 KB
templates/explode.pyexecutablescript11.0 KB
templates/fade.pyexecutablescript9.9 KB
templates/flip.pyexecutablescript9.2 KB
templates/kaleidoscope.pyexecutablescript6.2 KB
templates/morph.pyexecutablescript11.0 KB
templates/move.pyexecutablescript9.2 KB
templates/pulse.pyexecutablescript8.4 KB
templates/shake.pyexecutablescript3.6 KB
templates/slide.pyexecutablescript9.1 KB
templates/spin.pyexecutablescript8.9 KB
templates/wiggle.pyexecutablescript9.8 KB
templates/zoom.pyexecutablescript9.9 KB

templates/kaleidoscope.py

View on GitHub
#!/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)
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 323kUpdated Claude CodeCodexVerifiedInstall