Sequence Processing & Animation

360 Hextile supports batch processing of image sequences with specialized temporal noise settings to eliminate static noise patterns in animations.

Overview

When processing sequences of 360° images (video frames, time-lapses, etc.), standard diffusion processing can create visible "frozen" noise artifacts. The temporal noise system solves this by varying the noise pattern across frames while maintaining determinism.

Creating a Sequence

1. Switch to Sequence Mode in the Input tab
2. Select a folder containing your image sequence
3. Configure processing settings
4. Start the sequence

Supported Formats

• PNG, JPG, JPEG, WebP, TIFF, EXR
• Images are sorted alphabetically/numerically
• Recommended: Use consistent naming (e.g., frame_0001.png, frame_0002.png)

Playback & Preview

Setting Default Playback Speed

In the Input tab, you can configure the default playback FPS for sequence animations:

This setting is saved to your configuration file and used as the default when viewing sequences. You can change the playback speed at any time on the sequence details page.

Sequence Details Page

Once you create a sequence, you can: - Preview rendered frames - View completed frames in real-time - Control playback - Play/pause animation with transport controls - Adjust playback speed - Change FPS on-the-fly using the speed dropdown (includes preset options and custom FPS input) - Navigate frames - Jump to specific frames or use arrow keys - Monitor progress - Track rendering status of each frame

Playback Speed Options: - Preset FPS: 5, 10, 15, 24, 30, 60, 120 - Custom: Select "Custom" to enter any FPS value (1-240)

Keyboard Shortcuts: - Space - Play/pause - → - Next frame - ← - Previous frame

Temporal Noise Strategy

The Problem

In standard processing, each tile at position X receives the same noise pattern (base_seed + tile_index) across all frames. This creates visible "static" artifacts where diffusion patterns remain frozen while content moves.

The Solution

The temporal noise system adds frame-based variation to eliminate static patterns. Choose from 5 strategies with different quality/performance tradeoffs.

Noise Strategies

1. Tile Increment (Original)

Strategy ID: tile_increment

The original behavior. Each tile gets base_seed + tile_index, but the same tile position gets identical noise across all frames.

Warning: May show visible static noise patterns in animations.

2. Frame Offset (Recommended)

Strategy ID: frame_offset

Each frame gets an offset: base_seed + (frame_index × multiplier) + tile_index

This shifts the noise pattern each frame, eliminating static appearance while remaining fully deterministic.

Settings: - Frame Multiplier (default: 7919) - Higher values = faster noise variation. Prime numbers recommended.

3. Frame Hash

Strategy ID: frame_hash

Uses hash-based deterministic variation for a more "random" distribution between frames.

4. SLERP (Noise Interpolation)

Strategy ID: slerp

Spherical linear interpolation between noise "keyframes". Creates smoothest transitions.

How it works: 1. Every N frames is a "keyframe" with generated noise 2. Frames between keyframes interpolate using spherical interpolation 3. Creates smooth transitions while maintaining diffusion quality

Settings: - Keyframe Interval (default: 8) - Frames between noise keyframes. Lower = smoother but more computation.

5. Optical Flow

Strategy ID: optical_flow

Motion-guided noise warping. Uses optical flow to warp the previous frame's noise according to motion, then blends with fresh noise.

How it works: 1. Calculate optical flow between consecutive frames 2. Warp previous frame's noise using the flow field 3. Blend with fresh noise to prevent accumulation artifacts

Settings: - Fresh Noise Blend (default: 15%) - Amount of new noise mixed in each frame. Prevents pattern accumulation.

Requirements: - OpenCV (opencv-python) for flow calculation

Warning: Significantly increases render time (~3-4x slower). Use for final exports.

Configuration

The Temporal Noise Strategy card appears in the Diffusion tab when in Sequence Mode:

1. Select your strategy from the grid
2. Adjust strategy-specific settings
3. Performance indicators show overhead for each option

Config File (.hextile.json)

Sequence settings are stored in the input section:

{
  "input": {
    "mode": "sequence",
    "sequence_fps": 30,
    "increment_tile_seeds": true,
    "randomize_seed_per_frame": false,
    "noise_strategy": "frame_offset",
    "frame_multiplier": 7919,
    "slerp_keyframe_interval": 8,
    "flow_blend_ratio": 0.15
  }
}

API Parameters

When creating sequences via API:

Strategy Selection Guide

Performance Comparison

For a 44-tile template sequence:

Note: These are overhead times on top of normal diffusion processing.

Existing Seed Settings

The temporal noise strategies work alongside existing seed settings:

Increment Tile Seeds

• Enabled (default): Each tile position gets a different base seed
• Disabled: All tiles use the same seed

Randomize Seed Per Frame

• Enabled: Each frame gets a completely random seed (may cause flickering)
• Disabled: Frames use deterministic seeds based on base_seed

Recommended Combinations

Temporal Propagation

Temporal Propagation is an advanced feature that dramatically speeds up sequence rendering by only running full diffusion on keyframes and propagating results to in-between frames.

Overview

When enabled, only every Nth frame (keyframes) are processed with full SDXL/SD3.5 diffusion. In-between frames are generated by warping keyframe content using motion vectors, resulting in ~2-5x faster rendering and flicker-free animation.

Enabling Temporal Propagation

1. Switch to Sequence Mode in the Input tab
2. Navigate to the Temporal tab
3. Check Enable Temporal Propagation
4. Configure settings as needed

Note: Temporal propagation is only available for SDXL pipeline currently.

Keyframe Settings

Keyframe Interval

Range: 2-48 frames (default: 8)

How many frames between full diffusion keyframes:

Formula: Only frames 0, N, 2N, 3N... get full diffusion processing.

Keyframe Strength

Range: 0.1-1.0 (default: 0.45)

Diffusion strength applied to keyframes. Lower values preserve more of the original frame content.

Propagation Mode

Choose how in-between frames are generated:

Latent Space (Smoother)

Propagation happens in the VAE latent space: - Smoother transitions between frames - Requires VAE encode/decode - Better for stylized content

Pixel Space (Sharper, EbSynth-like)

Propagation happens directly on pixels: - Sharper, more detailed results - Battle-tested approach (similar to EbSynth) - Better for preserving fine details

Motion Source

Configure where motion information comes from:

Guidance Folder (EXR)

For Unreal Engine renders, specify the folder containing EXR guidance data: - Depth maps (*_depth.exr) - Normal maps (*_normal.exr) - Motion vectors (*_motion.exr)

Guidance Options

• Use Depth Guidance: Enable depth-aware propagation (prevents foreground/background blending)
• Use Normal Guidance: Enable normal-aware propagation (preserves surface details)

Blending Settings

Bidirectional Blend

When enabled, in-between frames blend from both the previous and next keyframes:

• Enabled (recommended): Smoother results, especially for camera motion
• Disabled: Only forward propagation from previous keyframe

Blend Falloff

How the blend weight changes between keyframes:

Repair Settings

When propagation produces low-confidence areas (occlusions, disocclusions), repair passes fix them:

Repair Threshold

Range: 0.1-0.95 (default: 0.7)

Confidence level below which repair is triggered: - Lower values (0.3-0.5): More repair passes, higher quality - Higher values (0.7-0.9): Less repair, faster rendering

Repair Strength

Range: 0.05-0.5 (default: 0.15)

Diffusion strength for repair inpainting. Lower values blend more smoothly with surrounding content.

Repair ControlNet Strength

Range: 0.0-2.0 (default: 1.0)

ControlNet strength applied during repair passes. Higher values maintain more structural guidance.

Config File (Temporal Propagation)

Temporal propagation settings are stored in the temporal section:

{
  "temporal": {
    "enabled": true,
    "keyframe_interval": 8,
    "keyframe_strength": 0.45,
    "propagation_mode": "latent",
    "motion_source": "auto",
    "guidance_folder": "",
    "use_depth": true,
    "use_normals": true,
    "repair_threshold": 0.7,
    "repair_strength": 0.15,
    "repair_controlnet_strength": 1.0,
    "bidirectional_blend": true,
    "blend_falloff": "cosine"
  }
}

When to Use Temporal Propagation

Per-Frame Retry

If individual frames fail during sequence processing, you can retry them without reprocessing the entire sequence:

1. Go to the sequence details page
2. Failed frames are marked with an error indicator
3. Click Retry on any failed frame
4. Only that frame will be reprocessed

This is particularly useful for: - VRAM-related failures on complex frames - Network interruptions during model downloads - Recovering from temporary GPU issues

Troubleshooting

Static noise patterns visible

Cause: Using tile_increment strategy Solution: Switch to frame_offset or another temporal strategy

Flickering between frames

Cause: randomize_seed_per_frame enabled with fast variation Solution: Disable randomize_seed_per_frame, use frame_offset

Slow rendering with optical_flow

Cause: Flow calculation overhead (~300ms/frame) Solution: Use frame_offset for previews, optical_flow only for final export

Memory issues with long sequences

Cause: SLERP/optical_flow cache buildup Solution: Cache is auto-cleared when sequence completes. For very long sequences, consider processing in batches.

Technical Details

Implementation

The noise system is implemented in backend/processors/noise.py as a singleton NoiseGenerator class:

• Thread-safe with locking for concurrent renders
• Automatic cache management per sequence
• Fallback to frame_offset for invalid strategies

Cache Management

• SLERP keyframes are cached per (sequence_id, tile_index)
• Optical flow state persists per (sequence_id, tile_index)
• Caches are automatically cleared when:
• Sequence completes or fails
• Sequence is deleted
• Application shuts down

Next Steps

• User Interface Guide - Complete UI documentation
• ControlNet Guide - Using ControlNet with sequences
• API Reference - Sequence API endpoints
• Troubleshooting - Fix common issues

Last Updated: 2026-01-22 | Temporal Noise & Propagation System v2.0