jumpstation

Silhouette: Image Processing Pipeline

Overview

Silhouette is the JumpStation image preprocessing pipeline. It prepares visual assets — app icons, sprites, UI artwork — for use on JumpStation devices by normalizing them to device-appropriate formats, resolutions, and color depths.

Every image that ships inside a JumpBundle or is displayed in the launcher passes through Silhouette at build time. The goal is that no runtime image processing is needed on-device; assets arrive ready to render.

What Silhouette Does

1. Background Removal

App icons on JumpStation use a transparent or solid-color compositing model. Silhouette can detect and remove backgrounds from source artwork, producing clean subject-only images suitable for layered UI rendering.

Supported techniques:

Edge-based alpha extraction
Chroma key removal (green screen / solid color)
Threshold-based separation for simple artwork

2. Palette Reduction

Many JumpStation devices have constrained display capabilities — limited color depth, indexed palettes, or monochrome outputs. Silhouette remaps images to a target palette at build time so the launcher and runtime never need to perform color conversion.

Supported modes:

Full 24-bit RGB (for Turbo and Kidputer)
16-bit RGB565 (for Jumpcade)
8-bit indexed (for legacy and Pico display modules)
1-bit monochrome (for e-ink or OLED targets)

3. Normalization

Assets are resized and cropped to standard dimensions defined by the target device profile. Standard icon sizes are defined in each device profile under devices/<device-name>/.

4. Format Export

Silhouette exports processed images in the format expected by the target device:

PNG with alpha (standard)
Raw RGB/RGBA byte arrays (for embedded targets)
BMP (for legacy compatibility)

Pipeline Stages

Source Image
     │
     ▼
[preprocessing.py]
  - Load and validate source
  - Normalize orientation (EXIF rotation)
  - Convert to working color space
     │
     ▼
[extractor.py]
  - Background removal
  - Alpha mask generation
  - Edge sharpening
     │
     ▼
[preprocessing.py]
  - Resize to target dimensions
  - Apply palette reduction
  - Output format conversion
     │
     ▼
Processed Asset (embedded in JumpBundle)

Module Reference

`core/silhouette/preprocessing.py`

Handles ingestion, normalization, resizing, palette reduction, and export. This is the outer shell of the pipeline — it calls into extractor.py for the extraction stage.

`core/silhouette/extractor.py`

Handles the background removal and alpha extraction stage. Accepts an image array and a target extraction mode, returns an RGBA image with the background separated.

Usage (Planned)

from core.silhouette.preprocessing import SilhouettePipeline

pipeline = SilhouettePipeline(device_profile="jumpcade")
output = pipeline.process("source_icon.png", mode="extract_bg")
output.save("icon_processed.png")