Nebula Flythrough

Turn one still astro image into a cinematic MP4 flythrough — no video software required.

1. What the tool does

You give it between one and three images (starless is required, mid layer is optional, stars layer is optional). For each layer you configure a "camera move" — where the camera starts, where it ends, how fast it zooms, how it eases between the two. On export, the tool renders every frame at your target resolution and FPS, composites the layers together, and writes an MP4.

Because each layer can have its own zoom speed, you get parallax for free: zoom the starless layer from 1× to 6× and the stars layer from 1× to 4×, and the stars appear to drift behind the nebula as you fly through it. Add the "Nebula depth warp" effect and bright structures actually come forward on the Z axis.

2. The three-layer system

Each layer has independent zoom, center, easing, lens effects, blend mode, and opacity. The compositing order is fixed:

3. Common workflow

1. Prepare your images in SASpro. Open your fully-processed nebula shot, then run a star-removal step (Remove Stars tool) to produce a starless view and a stars-only view. Both now exist as docs in SASpro.
2. Open Nebula Flythrough from the Tools menu.
3. Pick sources for each layer from the three Source dropdowns. Starless is required; Mid is "-- none --" by default; Stars is "-- select --".
4. Set the camera for the starless layer: Zoom start 1.0, Zoom end 6.0 is a reliable "fly in" setting. Click a point on the picker image to set the Start center, then click somewhere else for the End center (or just leave both at 0.5).
5. Set the camera for the stars layer: usually a slower zoom (e.g. 1.0 to 3.0) and the same center points. The zoom difference creates parallax.
6. Set the output size, FPS, and duration in the Output panel. 1920×1080 at 30 fps for 10 s is a solid default (300 frames).
7. Scrub the preview slider to inspect intermediate frames. Hit Play Preview to see the whole motion at low res.
8. Enable effects as desired: Nebula depth warp for 3D feel, Zoom blur for warp speed, Chromatic aberration for sci-fi vibe.
9. Click Export Video... and pick an MP4 destination. The tool renders at full source resolution (not the working preview resolution) and shows per-frame progress.

4. Camera controls per layer

5. Lens effects

Each layer has an identical "Lens Effects" box with four optional effects, plus a master "Ramp effects with zoom" checkbox that controls when they kick in.

6. Blend modes

Twelve blend modes are available for the mid and stars layers:

7. Workflow recipes

8. Preview vs. export resolution

The Working res dropdown (in the Output panel) controls the resolution used for the live preview — SD, HD, 2K, 4K, or Full. Smaller working resolutions make the preview more responsive and depth-map calculations faster, especially for very large source images.

9. GPU vs. CPU rendering

If PyTorch is installed and a CUDA GPU or Apple Silicon MPS device is available, rendering runs on the GPU automatically. The status line during export shows [GPU] or [CPU] per frame so you can confirm which backend is active. The pipeline silently falls back to CPU if GPU rendering fails on any frame — your render will finish either way, just slower on CPU for high resolutions.

Typical speedup from GPU: 5-15× on a modern discrete card, 3-5× on Apple Silicon. For a 10-second 1080p30 render (300 frames), that's the difference between coffee-break and an entire movie.

10. Technical details

The easing curves, the torus-wrapped zoom crop, the depth-aware parallax, the blend-mode math, the motion-coupled effect ramp, and the GPU grid-sample pipeline.

10.1 Easing functions

Four easing curves map normalized time t ∈ [0, 1] to an eased t ∈ [0, 1]:

Each layer picks its own curve independently — a common technique is Ease In for the starless layer and Linear for the stars layer, which makes the nebula accelerate forward while the starfield slides past at constant speed, selling parallax more strongly.

10.2 Zoom crop with torus wrap

Given a zoom factor z and center (c_x, c_y) in fractional image coordinates, the crop window dimensions are:

The window spans:

and samples are taken on a regular grid interpolated into an output of size (out_h, out_w). When the crop window extends beyond the image boundary — common at high zoom near the edge — the coordinates wrap modulo (W, H):

This is a torus wrap boundary mode — the image is treated as a seamlessly tileable texture. Unlike reflect or clamp modes, it never produces visible edge streaks or mirror reflections at the frame boundary, which was a visual flaw of earlier approaches. OpenCV's cv2.remap with BORDER_WRAP handles this on the CPU path; on GPU, normalized coordinates are folded with a custom modulo on [-1, 1].

10.3 Depth-aware parallax zoom

With Nebula depth warp enabled, each output pixel's source location is perturbed radially based on local luminance. The pipeline:

1. Build a depth map from the source: luminance Y = 0.299R + 0.587G + 0.114B, Gaussian-blurred by σ (default 8 px) to avoid noise, optionally inverted (dark = closer), then normalized to [0, 1].
2. For each output pixel (u, v) in normalized grid coordinates u, v ∈ [-0.5, 0.5], compute the base source location (x₀, y₀) using the zoom crop math above.
3. Compute the radial direction from the zoom center:
   (n_x, n_y) = \left(\frac{dx}{\sqrt{dx^2 + dy^2}}, \frac{dy}{\sqrt{dx^2 + dy^2}}\right)
   where (dx, dy) = (u · W_crop, v · H_crop).
4. Sample the depth map at the base source location to get d, and center around 0.5:
   d_c = d - 0.5
5. Compute the parallax shift in pixels, scaled by both the user strength s_d and the current zoom:
   p = d_c \cdot s_d \cdot (z - 1) \cdot 2
   The (z - 1) factor means parallax activates only during zoom — at z = 1 (fit to frame), the effect contributes nothing. The factor of 2 is a visual calibration constant.
6. Apply the shift radially:
   (x_s, y_s) = (x_0 - n_x p, \; y_0 - n_y p)
   Bright regions (d > 0.5) move toward the camera center as you zoom in, appearing closer; dark regions move outward, appearing further.
7. Sample the source image at (x_s, y_s) with torus wrap.

The result is per-pixel differential zoom — the nebula's brightest arcs lean forward during the fly-in, dust lanes recede, all without a true 3D model.

10.4 Blend-mode math

All blend modes operate pixelwise, per channel, on float32 values in [0, 1]. a is the base (lower) layer, b is the layer being blended on top:

Hard Light swaps the condition in Overlay to test b < 0.5 instead of a. Max/Lighten take max(a, b); Darken takes min(a, b); Average is (a + b)/2. The Soft Light formula is the Pegtop variant — simpler and more stable than the Photoshop recipe, and visually indistinguishable for typical use.

After the blend, opacity α interpolates between base and blended:

10.5 Threshold Mask (special blend mode)

Threshold Mask is an alpha composite rather than a pixelwise blend. Luminance of the top layer m drives a per-pixel alpha:

where τ is the Threshold slider and σ is the Feather slider. The final result is a straight over-composite:

This gives you a clean mask that fades smoothly within a σ-wide luminance band around τ. For a stars layer, setting τ ≈ 0.15 and σ ≈ 0.08 makes the stars sit cleanly on top of the base while the dark gaps between stars reveal the layers beneath.

10.6 Radial edge stretch

For each pixel at offset (dx, dy) from the zoom center, with half-diagonal of the frame as the normalizing length, the normalized radius is:

and the source sample location becomes:

where k is the strength slider. The r² factor means the center is unaffected while edges distort most — standard radial distortion. Positive k gives barrel distortion (edges pushed outward); negative k gives pincushion (edges pulled inward). Range of the strength slider is [-0.5, 0.5].

10.7 Zoom blur (warp-speed streaks)

Zoom blur is implemented as a multi-sample accumulation at progressive zoom levels. For N samples (default 12):

where z_max = 1 + 0.25 · s. The samples are weighted so the undistorted (i=0) sample has weight 1 and the most-zoomed sample has weight 0.4, giving a trailing look rather than a smeared one. The weighted average is blended into the original image at blend factor 0.7 · s:

Visually: stars become radial streaks pointing away from the zoom center, with the streak length controlled by the strength slider.

10.8 Chromatic aberration

Red and blue channels are independently zoomed with a small offset relative to green:

Red zooms in (shifts inward toward center), blue zooms out (shifts outward toward edges). The green channel is left unchanged. This mimics the way real refractors with imperfect correction spread colors radially at the edges of the field, giving a lens-realism feel. At s = 1 (max slider), the shift is 3% — enough to see at the frame edges, invisible near center.

10.9 Motion-coupled effect ramp

With "Ramp effects with zoom" enabled, each effect's strength is modulated by the current zoom velocity, not by elapsed time. For eased time function f(t), the velocity at time t is approximated by a small central difference:

normalized to a visual ramp:

with ε = 0.005. The effect strength the user set in the slider is then multiplied by ramp(t) before being applied. For an Ease In curve, v(0) ≈ 0 and v(1) is maximum — so chromatic aberration and zoom blur both ease in with the camera's acceleration. For Linear, v is constant and the effects stay pinned at their slider values. The divisor 3 is empirical: it means Ease In-Out and Linear end up at roughly the same peak effect strength despite having very different velocity curves.

10.10 Compositing order

The final frame is built in two steps:

When the mid layer is absent, step 1 is skipped and base = starless. When the stars layer is absent, step 2 is skipped and the final frame is base. The default stars blend is Screen with opacity 1.0, which reproduces the classic "stars-plus-nebula" composite you'd otherwise do manually.

10.11 GPU acceleration via grid_sample

When PyTorch is available with a CUDA or MPS backend, the zoom crop, radial stretch, zoom blur, chromatic aberration, and depth warp are all implemented via torch.nn.functional.grid_sample operating on NCHW tensors. The GPU-side torus wrap is implemented by folding normalized grid coordinates into [-1, 1]:

which is equivalent to the modulo wrap in image space. The GPU path uses padding_mode="zeros" because the wrap already keeps all coordinates inside [-1, 1], so the zero-padding fallback is never actually triggered.

Depth maps are uploaded once per render to a (1, 1, H, W) tensor, then sampled on-GPU each frame. Images are stored on-GPU as (1, 3, H, W) float32. Each layer composite is a Python function call that returns a tensor, so blend modes can chain without any CPU round-trip — only the final (1, 3, out_h, out_w) frame is pulled back to numpy and converted to BGR uint8 for the OpenCV MP4 writer.