synthesis op• Data kinds: none → lightfield (an op determined by its arguments alone — it takes no image or data input)
• Call: import lightfield; lightfield.lf_synthesize(slopes=(0.0,), angular=(5, 5), shape=(64, 64), *, occlusion=True, coverage=0.55, texture_sigma=2.0, interp='linear', edge='wrap', seed=0) (or opslightfield.get("lf_synthesize"))
Build a light field of textured layers at known slopes (the test bed).
Each entry of *slopes* is one fronto-parallel layer, given as its slope
`s = dx/du` in pixels of image shift per angular step; the layer's
texture is band-limited noise (Gaussian-smoothed, `texture_sigma` px) and
view `(v, u) sees it displaced by (s*(v - v_c), s*(u - u_c))`. Because
the displacement is exactly linear in the angular index, every downstream
answer is closed-form: the refocus sharpness peaks at `s`, the EPI lines
have slope `s`, and the disparity between the extreme views is
`s * (U - 1)`.
*angular* is `(V, U) and *shape* is (H, W)`.
With `occlusion=True` (default) the layers are composited front-to-back by
`|slope| (largest |s|` = nearest = drawn last) through random binary
masks covering roughly *coverage* of the frame, and the layer with the
smallest `|slope|` is forced opaque as the background — **regardless
of its position in *slopes*** (a tie goes to the earlier entry, the sort is
stable). `(0.0, 2.0) and (2.0, 0.0)` therefore describe the same
scene with the same `slope_map`; only the per-layer textures are drawn in
a different order. That is what makes a
see-through synthetic-aperture test meaningful. With `occlusion=False` the
layers are averaged instead — a transparent superposition, which is the
cleanest possible input for refocusing because each layer survives the
average untouched.
Returns `(light_field, slope_map): the (V, U, H, W)` array and the
`(H, W)` map of the front-most layer's slope at each pixel — the ground
truth for :func:lf_depth_from_focus and :func:lf_epi_slope. The map is
in centre-view coordinates (the masks are stated unshifted, and the
centre view is the one view whose shift is zero), which is also the frame a
refocused image lands in. With
`occlusion=False` the light field also contains the *other* layers at
every pixel, so a depth estimator will legitimately disagree with the map
wherever layers overlap; the single-layer case is unambiguous and is what
the exactness tests use.
`edge="wrap"` (default) makes the scene periodic so an integer slope is a
pure `np.roll` and the whole pipeline is bit-exact end to end (measured
round-trip error 5.6e-16); `edge="nearest"` reproduces a real camera's
border clamping.
Raises `ValueError`: an empty or over-long *slopes* list
(:data:MAX_LAYERS), a non-finite or over-large slope
(:data:MAX_ABS_SLOPE), an angular or spatial shape outside
`[1, MAX_ANGULAR] / [1, MAX_SPATIAL]`, a total size over
:data:MAX_LF_ELEMENTS, *coverage* outside `(0, 1]`, a *texture_sigma*
so large the smoothed texture's dynamic range falls below
:data:MIN_TEXTURE_RANGE, and an unknown *interp* / *edge*.
• lightfield_depth family guide
• Sample-data catalog (download URLs / licences) — 2-D uses skimage.data (BSD/public domain) plus synthetic images; 3-D lists download URLs for real data sources (Stanford, PDS, …).
• Operator provenance and references — the sources of the research/methods this op family came from.
• The canonical algorithm (author, year) and its uses are named in the family usage guide above.
• lightfield_depth — py -3.11 examples/lightfield_depth.py
lightfield as input)lf_to_mla · lf_stats · lf_subaperture · lf_center_view · lf_views · lf_epi · lf_refocus · lf_focal_stack
synthesis)—
*Provenance: lightfield.py — LIGHTFIELD operator registry. This per-op note is generated by tools/opdocs.py md (do not hand-edit).*
© 2026 Kazufumi Furuse — Fullseye operator documentation. Licensed under Apache-2.0.