logic-lab 0.4.0__py3-none-any.whl

logic_lab/__init__.py

@@ -0,0 +1,16 @@
+"""
+Logic Lab - Creative coding algorithms and simulations using py5.
+
+A comprehensive collection of generative art algorithms organized by domain:
+physics, steering behaviors, genetic algorithms, neural networks, fractals,
+cellular automata, tiling patterns, and mathematical systems.
+
+All simulations are interactive and can be run with py5. The MCP server
+provides AI agent access to algorithm references and implementations.
+"""
+
+__version__ = "0.4.0"
+__author__ = "Asami Kakuishi"
+__email__ = "asami@asami.tokyo"
+
+__all__ = ["version"]

logic_lab/audio_sync/__init__.py

@@ -0,0 +1,5 @@
+"""Audio synchronization and frequency-responsive visualization algorithms.
+
+This domain contains algorithms that respond to audio input, including
+frequency analysis, spectrum visualization, and audio-driven effects.
+"""

logic_lab/audio_sync/audio_reactive_particles/README.md

@@ -0,0 +1,11 @@
+# Audio-Reactive Particles
+
+Real-time visualization of audio frequencies through particles that spawn and animate in response to bass, mid, and high-frequency content from microphone input or simulated audio.
+
+```bash
+uv run python src/logic_lab/audio_sync/audio_reactive_particles/audio_reactive_particles.py
+```
+
+Press `m` to toggle between microphone input and demo mode, `s` to save a screenshot, `r` to reset, or `SPACE` to pause.
+
+The system analyzes audio frequencies using FFT, mapping bass to explosion radius, mid-frequencies to spawn rate, and high frequencies to color shifts (blue → purple → pink).

logic_lab/audio_sync/audio_reactive_particles/__init__.py

@@ -0,0 +1,17 @@
+"""Audio-Reactive Particles - Frequency-driven particle visualization system."""
+
+from .audio_reactive_particles import (
+    HAS_SOUNDDEVICE,
+    AudioCapture,
+    AudioParticle,
+    AudioReactiveField,
+    SpectrumBand,
+)
+
+__all__ = [
+    "HAS_SOUNDDEVICE",
+    "AudioParticle",
+    "SpectrumBand",
+    "AudioCapture",
+    "AudioReactiveField",
+]

logic_lab/audio_sync/audio_reactive_particles/audio_reactive_particles.py

@@ -0,0 +1,407 @@
+"""Audio-reactive particles system with frequency-driven visualization.
+
+This module provides real-time audio visualization through particle systems
+that react to different frequency bands (bass, mid, high) from audio input.
+When sounddevice is not available, it gracefully falls back to demo mode
+with simulated audio signals.
+"""
+
+import math
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+import numpy as np
+import py5
+
+try:
+    import sounddevice as sd
+
+    HAS_SOUNDDEVICE = True
+except ImportError:
+    HAS_SOUNDDEVICE = False
+
+
+@dataclass
+class AudioParticle:
+    """A single particle in the audio-reactive system.
+
+    Attributes:
+        x: Horizontal position (0-width)
+        y: Vertical position (0-height)
+        vx: Horizontal velocity
+        vy: Vertical velocity
+        life: Lifetime from 0 (dead) to 1 (newborn)
+        color: RGB color tuple (0-255)
+    """
+
+    x: float
+    y: float
+    vx: float
+    vy: float
+    life: float
+    color: tuple[int, int, int]
+
+    def update(self, gravity: float = 0.98) -> None:
+        """Update particle position and apply physics.
+
+        Args:
+            gravity: Velocity damping factor per frame
+        """
+        self.x += self.vx
+        self.y += self.vy
+        self.vx *= gravity
+        self.vy *= gravity
+        self.life -= 0.02
+
+    def is_alive(self) -> bool:
+        """Check if particle is still active."""
+        return self.life > 0
+
+
+@dataclass
+class SpectrumBand:
+    """Normalized frequency spectrum bands.
+
+    Attributes:
+        bass: Energy in 0-300Hz range (0-1)
+        mid: Energy in 300-3000Hz range (0-1)
+        high: Energy in 3000Hz+ range (0-1)
+    """
+
+    bass: float = 0.0
+    mid: float = 0.0
+    high: float = 0.0
+
+    def normalize(self) -> None:
+        """Normalize bands to sum to 1 (within tolerance)."""
+        total = self.bass + self.mid + self.high
+        if total > 1e-9:
+            self.bass /= total
+            self.mid /= total
+            self.high /= total
+
+
+class AudioCapture:
+    """Captures audio from microphone and computes FFT spectrum.
+
+    This class manages audio input and frequency analysis. It runs
+    audio capture in a background thread and provides thread-safe
+    access to the current spectrum.
+
+    Attributes:
+        sample_rate: Sample rate in Hz (default 22050)
+        chunk_size: Audio chunk size (default 1024)
+    """
+
+    def __init__(self, sample_rate: int = 22050, chunk_size: int = 1024):
+        """Initialize audio capture.
+
+        Args:
+            sample_rate: Audio sample rate in Hz
+            chunk_size: Number of samples per chunk
+        """
+        self.sample_rate = sample_rate
+        self.chunk_size = chunk_size
+        self.is_active = False
+        self.stream: sd.InputStream | None = None
+
+        self._spectrum_lock = threading.Lock()
+        self._current_spectrum = SpectrumBand()
+        self._audio_buffer: list[np.ndarray] = []
+
+    def start(self) -> None:
+        """Start capturing audio from microphone."""
+        if not HAS_SOUNDDEVICE:
+            return
+
+        if self.is_active:
+            return
+
+        self.is_active = True
+        self.stream = sd.InputStream(
+            channels=1,
+            samplerate=self.sample_rate,
+            blocksize=self.chunk_size,
+            callback=self._audio_callback,
+            dtype=np.float32,
+        )
+        self.stream.start()
+
+    def stop(self) -> None:
+        """Stop capturing audio."""
+        self.is_active = False
+        if self.stream is not None:
+            self.stream.stop()
+            self.stream.close()
+            self.stream = None
+
+    def _audio_callback(self, indata: np.ndarray, frames: int, time_info, status) -> None:
+        """Callback for audio stream processing."""
+        if status:
+            return
+
+        audio_data = indata[:, 0].copy().astype(np.float32)
+        self._process_spectrum(audio_data)
+
+    def _process_spectrum(self, audio_data: np.ndarray) -> None:
+        """Compute FFT and extract frequency bands."""
+        # Compute FFT
+        spectrum = np.abs(np.fft.rfft(audio_data))
+        freqs = np.fft.rfftfreq(len(audio_data), 1 / self.sample_rate)
+
+        # Extract frequency bands
+        bass_mask = freqs < 300
+        mid_mask = (freqs >= 300) & (freqs < 3000)
+        high_mask = freqs >= 3000
+
+        bass_energy = spectrum[bass_mask].sum()
+        mid_energy = spectrum[mid_mask].sum()
+        high_energy = spectrum[high_mask].sum()
+
+        # Normalize
+        total = bass_energy + mid_energy + high_energy
+        if total > 1e-9:
+            bass = bass_energy / total
+            mid = mid_energy / total
+            high = high_energy / total
+        else:
+            bass = mid = high = 0.0
+
+        with self._spectrum_lock:
+            self._current_spectrum.bass = bass
+            self._current_spectrum.mid = mid
+            self._current_spectrum.high = high
+
+    def get_spectrum(self) -> SpectrumBand:
+        """Get current spectrum bands (thread-safe).
+
+        Returns:
+            SpectrumBand with normalized frequency data
+        """
+        with self._spectrum_lock:
+            return SpectrumBand(
+                bass=self._current_spectrum.bass,
+                mid=self._current_spectrum.mid,
+                high=self._current_spectrum.high,
+            )
+
+
+class AudioReactiveField:
+    """Main audio-reactive particle system.
+
+    This class manages particles and responds to audio input. It can run
+    in real-time mode (with microphone) or demo mode (with simulated audio).
+
+    Attributes:
+        particles: List of active particles
+        capture: AudioCapture instance (None if running in demo mode)
+        demo_mode: True if running without audio input
+    """
+
+    def __init__(self, width: int = 800, height: int = 600):
+        """Initialize the audio-reactive field.
+
+        Args:
+            width: Canvas width
+            height: Canvas height
+        """
+        self.width = width
+        self.height = height
+        self.particles: list[AudioParticle] = []
+
+        # Initialize audio capture
+        self.capture: AudioCapture | None = None
+        self.demo_mode = not HAS_SOUNDDEVICE
+
+        if HAS_SOUNDDEVICE:
+            self.capture = AudioCapture()
+            self.capture.start()
+        else:
+            print("sounddeviceなし。デモモードで実行します")
+
+        # Demo mode simulation
+        self.demo_time = 0.0
+        self.paused = False
+        self.bg_color = 10
+
+    def get_spectrum(self) -> SpectrumBand:
+        """Get current audio spectrum.
+
+        Returns:
+            SpectrumBand with frequency data (real or simulated)
+        """
+        if not self.demo_mode and self.capture is not None:
+            return self.capture.get_spectrum()
+
+        # Demo mode: simulate periodic audio
+        self.demo_time += 0.016  # ~60fps
+        bass = (math.sin(self.demo_time * 2) * 0.5 + 0.5) * 0.8
+        mid = (math.sin(self.demo_time * 4) * 0.3 + 0.3) * 0.6
+        high = (math.sin(self.demo_time * 8) * 0.3 + 0.3) * 0.6
+
+        spectrum = SpectrumBand(bass=bass, mid=mid, high=high)
+        spectrum.normalize()
+        return spectrum
+
+    def update(self) -> None:
+        """Update all particles and spawn new ones based on audio."""
+        if self.paused:
+            return
+
+        spectrum = self.get_spectrum()
+
+        # Update background based on bass
+        self.bg_color = int(10 + spectrum.bass * 40)
+
+        # Spawn new particles based on mid frequencies
+        spawn_count = 2 + int(spectrum.mid * 8)
+        self._spawn_particles(spawn_count, spectrum)
+
+        # Update existing particles
+        alive_particles = []
+        for particle in self.particles:
+            particle.update()
+            if particle.is_alive():
+                alive_particles.append(particle)
+
+        self.particles = alive_particles
+
+    def _spawn_particles(self, count: int, spectrum: SpectrumBand) -> None:
+        """Spawn new particles at center.
+
+        Args:
+            count: Number of particles to spawn
+            spectrum: Current spectrum for color control
+        """
+        center_x = self.width / 2
+        center_y = self.height / 2
+
+        # Explosion radius based on bass
+        radius = 100 + spectrum.bass * 200
+
+        for _ in range(count):
+            angle = np.random.uniform(0, 2 * math.pi)
+            speed = np.random.uniform(1, 4)
+
+            vx = math.cos(angle) * speed
+            vy = math.sin(angle) * speed
+
+            # Color shift based on high frequencies
+            # Blue -> Purple -> Pink
+            hue_shift = spectrum.high * 120
+            if hue_shift < 60:
+                # Blue to Purple
+                r = int(100 + hue_shift)
+                g = int(100 - hue_shift * 0.5)
+                b = 200
+            else:
+                # Purple to Pink
+                r = 200
+                g = int(100 - (hue_shift - 60) * 0.5)
+                b = int(200 - (hue_shift - 60))
+
+            particle = AudioParticle(
+                x=center_x,
+                y=center_y,
+                vx=vx,
+                vy=vy,
+                life=1.0,
+                color=(max(0, min(255, r)), max(0, min(255, g)), max(0, min(255, b))),
+            )
+            self.particles.append(particle)
+
+    def reset(self) -> None:
+        """Clear all particles."""
+        self.particles.clear()
+        self.demo_time = 0.0
+
+    def toggle_demo_mode(self) -> None:
+        """Toggle between demo and real audio mode."""
+        if not HAS_SOUNDDEVICE:
+            return
+
+        self.demo_mode = not self.demo_mode
+        if self.demo_mode:
+            if self.capture is not None:
+                self.capture.stop()
+        else:
+            if self.capture is not None:
+                self.capture.start()
+
+    def toggle_pause(self) -> None:
+        """Toggle pause/resume."""
+        self.paused = not self.paused
+
+    def cleanup(self) -> None:
+        """Clean up audio resources."""
+        if self.capture is not None:
+            self.capture.stop()
+
+
+# Global field instance for py5 sketch
+audio_field: AudioReactiveField | None = None
+
+
+def setup() -> None:
+    """Initialize the sketch."""
+    global audio_field
+    py5.size(1000, 800)
+    py5.smooth()
+    py5.background(0)
+    audio_field = AudioReactiveField(width=1000, height=800)
+    print(f"Demo mode: {audio_field.demo_mode}")
+    print("Controls: m=mode, s=screenshot, r=reset, SPACE=pause, q=quit")
+
+
+def draw() -> None:
+    """Main animation loop."""
+    if audio_field is None:
+        return
+
+    audio_field.update()
+    py5.background(audio_field.bg_color)
+
+    for particle in audio_field.particles:
+        alpha = int(particle.life * 255)
+        py5.fill(*particle.color, alpha)
+        py5.no_stroke()
+        py5.circle(particle.x, particle.y, 4)
+
+    py5.fill(200)
+    py5.text_size(11)
+    py5.text(f"FPS: {py5.get_frame_rate():.1f}", 10, 20)
+    py5.text(f"Particles: {len(audio_field.particles)}", 10, 35)
+    mode = "Demo" if audio_field.demo_mode else "Mic"
+    py5.text(f"Mode: {mode} (m to toggle)", 10, 50)
+    py5.text("s=screenshot, r=reset, SPACE=pause", 10, py5.height - 10)
+
+
+def key_pressed() -> None:
+    """Handle key presses."""
+    if audio_field is None:
+        return
+
+    key = py5.key
+
+    if key == "s":
+        filename = f"audio_reactive_{py5.frame_count:05d}.png"
+        py5.save_frame(filename)
+        print(f"Screenshot saved: {filename}")
+
+    elif key == "m":
+        audio_field.toggle_mode()
+
+    elif key == "r":
+        audio_field.particles.clear()
+
+    elif key == " ":
+        audio_field.toggle_pause()
+
+    elif key == "q":
+        py5.exit_sketch()
+
+
+if __name__ == "__main__":
+    py5.run_sketch()

logic_lab/audio_sync/audio_reactive_particles/example.py

@@ -0,0 +1,86 @@
+"""Example visualization of audio-reactive particles.
+
+This example demonstrates interactive audio-reactive visualization that responds
+to microphone input (or simulated audio in demo mode).
+
+Controls:
+  m - Toggle between microphone and demo mode
+  s - Save screenshot
+  r - Reset particles
+  SPACE - Pause/Resume
+  q - Quit
+"""
+
+try:
+    import py5
+except ImportError:
+    print("py5 is required for this example. Install with: pip install py5")
+    exit(1)
+
+from logic_lab.audio_sync.audio_reactive_particles import AudioReactiveField
+
+field: AudioReactiveField
+
+
+def setup() -> None:
+    """Initialize the sketch."""
+    global field
+    py5.size(1000, 800)
+    py5.smooth()
+    py5.background(0)
+    field = AudioReactiveField(width=1000, height=800)
+    print(f"Demo mode: {field.demo_mode}")
+    print("Controls: m=mode, s=screenshot, r=reset, SPACE=pause, q=quit")
+
+
+def draw() -> None:
+    """Main animation loop."""
+    # Update field
+    field.update()
+
+    # Draw background
+    py5.background(field.bg_color)
+
+    # Draw particles
+    for particle in field.particles:
+        alpha = int(particle.life * 255)
+        py5.fill(*particle.color, alpha)
+        py5.no_stroke()
+        py5.circle(particle.x, particle.y, 4)
+
+    # Draw info text
+    spectrum = field.get_spectrum()
+    py5.fill(200, 200, 200)
+    py5.text_size(12)
+    py5.text(f"Particles: {len(field.particles)}", 10, 20)
+    py5.text(f"Demo: {field.demo_mode}", 10, 40)
+    py5.text(f"Bass: {spectrum.bass:.2f}", 10, 60)
+    py5.text(f"Mid: {spectrum.mid:.2f}", 10, 80)
+    py5.text(f"High: {spectrum.high:.2f}", 10, 100)
+    py5.text(f"FPS: {py5.frame_rate:.0f}", 10, 120)
+
+
+def key_pressed() -> None:
+    """Handle keyboard input."""
+    if py5.key == "m":
+        field.toggle_demo_mode()
+        print(f"Switched to {'demo' if field.demo_mode else 'audio'} mode")
+    elif py5.key == "r":
+        field.reset()
+        print("Particles reset")
+    elif py5.key == " ":
+        field.toggle_pause()
+        print(f"{'Paused' if field.paused else 'Resumed'}")
+    elif py5.key == "s":
+        import time
+
+        filename = f"audio_particles_{int(time.time())}.png"
+        py5.save_frame(filename)
+        print(f"Screenshot saved: {filename}")
+    elif py5.key == "q":
+        field.cleanup()
+        py5.exit()
+
+
+if __name__ == "__main__":
+    py5.run_sketch()

logic_lab/biological/__init__.py

@@ -0,0 +1 @@
+from . import physarum

logic_lab/biological/ant_colony/README.md

@@ -0,0 +1,11 @@
+# Ant Colony Optimization
+
+Stigmergic ant navigation using pheromone deposition and evaporation.
+
+```bash
+uv run python src/logic_lab/biological/ant_colony/ant_colony.py
+```
+
+Press `s` to save a screenshot.
+
+Ants autonomously explore leaving pheromone trails.

logic_lab/biological/ant_colony/ant_colony.py

@@ -0,0 +1,97 @@
+import math
+import random
+from pathlib import Path
+
+import py5
+
+SCREENSHOT_DIR = Path(__file__).parent / "screenshots"
+ants: list[dict] = []
+pheromone_map: list[list[float]] = []
+
+
+def setup() -> None:
+    global ants, pheromone_map
+    py5.size(1000, 1000)
+    SCREENSHOT_DIR.mkdir(parents=True, exist_ok=True)
+
+    for _ in range(50):
+        ants.append(
+            {
+                "x": py5.width / 2,
+                "y": py5.height / 2,
+                "angle": random.uniform(0, 2 * math.pi),
+                "food": False,
+            }
+        )
+
+    grid_size = 50
+    pheromone_map = [[0.0] * grid_size for _ in range(grid_size)]
+
+
+def draw() -> None:
+    global pheromone_map
+    py5.background(20)
+
+    grid_x, grid_y = len(pheromone_map[0]), len(pheromone_map)
+    scale_x, scale_y = py5.width / grid_x, py5.height / grid_y
+
+    for ant in ants:
+        gx, gy = int(ant["x"] / scale_x), int(ant["y"] / scale_y)
+
+        if 0 <= gx < grid_x and 0 <= gy < grid_y:
+            pheromone_map[gy][gx] += 1
+
+            if pheromone_map[gy][gx] > 10:
+                ant["food"] = True
+
+        if ant["food"]:
+            ant["angle"] += random.uniform(-0.3, 0.3)
+        else:
+            best_angle = ant["angle"]
+            max_pheromone = 0
+
+            for test_angle in [ant["angle"] - 0.5, ant["angle"], ant["angle"] + 0.5]:
+                tx = int((ant["x"] + 20 * math.cos(test_angle)) / scale_x)
+                ty = int((ant["y"] + 20 * math.sin(test_angle)) / scale_y)
+
+                if 0 <= tx < grid_x and 0 <= ty < grid_y:
+                    if pheromone_map[ty][tx] > max_pheromone:
+                        max_pheromone = pheromone_map[ty][tx]
+                        best_angle = test_angle
+
+            ant["angle"] = best_angle
+
+        ant["x"] += 3 * math.cos(ant["angle"])
+        ant["y"] += 3 * math.sin(ant["angle"])
+
+        if ant["x"] < 0:
+            ant["x"] = py5.width
+        if ant["x"] > py5.width:
+            ant["x"] = 0
+        if ant["y"] < 0:
+            ant["y"] = py5.height
+        if ant["y"] > py5.height:
+            ant["y"] = 0
+
+        py5.fill(255, 150, 100) if ant["food"] else py5.fill(100, 150, 255)
+        py5.stroke_weight(0)
+        py5.circle(ant["x"], ant["y"], 2)
+
+    for pheromone_map[y][x] in enumerate(pheromone_map):
+        pheromone_map[y][x] *= 0.95
+
+    for y in range(len(pheromone_map)):
+        for x in range(len(pheromone_map[0])):
+            val = int(pheromone_map[y][x] * 2)
+            if val > 0:
+                py5.fill(val, 100, 200, min(val, 255))
+                py5.stroke_weight(0)
+                py5.rect(x * scale_x, y * scale_y, scale_x, scale_y)
+
+
+def key_pressed() -> None:
+    if py5.key == "s":
+        py5.save_frame(str(SCREENSHOT_DIR / "ant_colony_####.png"))
+
+
+py5.run_sketch()

logic_lab/biological/dla/README.md

@@ -0,0 +1,11 @@
+# Diffusion-Limited Aggregation (DLA)
+
+Particles perform random walks until they contact a growing aggregate, where they permanently stick. The resulting fractal cluster has a characteristic branching, dendritic form resembling snowflakes, coral, lightning, or mineral deposits.
+
+```bash
+uv run python src/logic_lab/biological/dla/dla.py
+```
+
+Press `1/2/3` to switch growth modes (radial/linear/circular), `r` to reset, `Space` to pause, or `s` to save a screenshot.
+
+Color encodes the order in which particles joined the aggregate: deep blue = early (old branches), white/cyan = recent growth. Radial mode grows a symmetric crystal from the center; linear grows a terrain-like boundary; circular fills inward from a ring seed.