Camera
The geometric chief-ray models, the kernels' view of the radiometric camera at a pose, and the vignetting's rules and gauge.
The radiometric camera itself (RadiometricCameraModel: a geometric camera with its focus surface, aperture radius and vignetting), its back-projection from the aperture (chief_direction, focus_point, backproject(camera, 𝐩, 𝐚), world_ray; the paper's 𝔣 and π̂⁻¹ are aliases there), the focus surface (Focus), the vignetting fields, the sensor domain and the quadrature rules on the pixel and the aperture are VisualRadiometryToolkitCore's: its manual documents them, and they are reached through that package (using VisualRadiometryToolkitCore: Focus). RadiometricCameraModel alone is re-exported here. A camera composed from its geometric camera has no vignetting (NoVignetting); a calibration estimates V, so its camera states a field — RadiometricCamera.flat_vignetting is the flat start.
Vignetting
RadiometricCamera.center_constraint — Method
center_constraint(v) -> (C::Matrix, d::Vector)The gauge V(𝐜) = 1 at the field's centre (VgtkCore.center: a tensor surface's sensor centre, a radial profile's centre of symmetry) as one linear row C ⋅ vec(P) = d.
RadiometricCamera.vignetting_center — Method
vignetting_center(camera) -> SVector{2, Float64}The centre of the radial vignetting profile of camera: its PRINCIPAL POINT, fixed (owner ruling 2026-11-11: the centre is no parameter of the fit, and V(𝐜) = 1 is held there exactly, gauge_basis), COLMAP pixels — the one source of truth: K's principal point. A parametric camera's K is physical; a SplineLens start is on its optical axis (grid_model: Estimation's fit_camera turns its source onto the axis, Core's axis_gauged, K's principal point the axis's pixel), so its K's principal point is the axis too — no separate optical_axis fit here (a start whose axis fit did not converge, grid_model, is not axis-gauged: its K's principal point, not the axis, for that run).
Geometric models and the camera at a pose
RadiometricCamera.in_domain — Function
Whether the camera images the sensor position 𝐩.
RadiometricCamera.flat_vignetting — Method
flat_vignetting(geometric) -> TensorProductVignettingThe calibration's start of the vignetting on the image of the geometric camera geometric: V ≡ 1 as a flat 4 × 4 quadratic B-spline surface over the image (VisualRadiometryToolkitCore's TensorProductVignetting((4, 4), Rect(0, 0, W, H); degree = 2)), the surface a calibration then estimates. A camera composed from its geometric camera alone has NoVignetting() (no Θv); a calibration's camera states the field: `RadiometricCameraModel(geometric; focus, apertureradius, vignetting = flat_vignetting(geometric))`.
RadiometricCamera.in_domain — Method
Whether the camera images the sensor position: its back-projection is finite there (a grid's: its 4 × 4 window holds present nodes) and, when its lens coverage is an image circle (Core's lens_coverage: a Circle or an Ellipse, the run's measured one), inside it. A Rect coverage (the whole sensor, the default) bounds no position: a position off the sensor that the lens images stays imaged, as the model's own domain says.
RadiometricCamera.lm_box — Method
lm_box(camera, W, H) -> NamedTupleThe Levenberg–Marquardt search box of a pixel camera's parameters of a W × H image, by Core's parameter names (f, aspect, skew, cx, cy, then the lens's parameter_names): a solver option, not a fact of any lens — the box of Core's ParameterManifold, which intersects it with the model's domain (parameter_bounds: f > 0, aspect > 0, the double sphere's ξ > −1 and α ∈ [0, 1]) and clamps every LM step into it. f between 0.1 and 50 image widths (a 180° fisheye to a 400 mm telephoto on APS-C; a cap of 3 widths once clamped a 65 mm lens and stalled the LM); the aspect f_y/f_x 0.1 … 10 (1 for square pixels); the principal point within 0.3 of the image's width and height of its centre; the double sphere's ξ ∈ [−0.95, 1.5] (the Siemens 17 mm lens fits ξ ≈ −0.6); OpenCV's sensor tilt within ±0.5 rad; any other parameter within ±10³.
RadiometricCamera.lm_scale — Method
lm_scale(W, H) -> NamedTupleThe coordinate scale of a pixel camera's LM block (Core's ParameterManifold(camera; scale)): one coordinate of the principal point (and of the skew) per image width and height, so the LM's uniform damping λ·I weighs it like the log-charted focal length and the unit-free lens coefficients (the hoist gate measured the Jacobian of the scaled pixel camera equal to the normalized image's to 2.2e-16).
RadiometricCamera.LATTICE_TAGS — Constant
The spellings of grid.lattice and the rule each reads as (read_switch's cases; the writer's switch_spelling).
RadiometricCamera.DerivedLattice — Type
grid.lattice = "derived": the start source's OWN lattice (T. Schöps's camera) extended over the sensor ∩ the lens coverage on its own spacing, split exactly by the integer m whose present nodes come closest to grid.node_count without exceeding it (no count: m = 1; exact_start, its internal exact_subdivision). A source without a lattice (a parametric camera) is refused.
RadiometricCamera.LatticeRule — Type
How a grid start's geometry lattice is made ([grid] lattice, parsed ONCE by read_switch through LATTICE_TAGS): DerivedLattice or NodeCountLattice. Every decision on it is a dispatch (start_grid).
RadiometricCamera.NodeCountLattice — Type
grid.lattice = "node_count": a lattice of square cells laid over the image region's bounding box, sized so the nodes the region supports come nearest grid.node_count (region_start; a parametric source). A SplineLens source is refused.
RadiometricCamera.calibrated_folds — Method
calibrated_folds(camera; device = default_device()) -> Union{Nothing, NamedTuple}The calibrated camera's check on output (the owner's fold policy, 2026-11-15), by its type: a SplineLens camera is held to the coverage assertion (check_coverage) over coverage_region and its folds are Core's folded_pixels over it ((; folded, samples, unimaged)); a parametric camera has no lattice to fold (nothing). A remaining fold flags the calibration non-converged (fold_termination).
RadiometricCamera.check_coverage — Method
check_coverage(camera, region; who, device = default_device()) -> regionThe coverage assertion, set-level: region ⊆ valid_domain(model(camera)) (Core's check_region_support, a RegionBeyondSupport naming who otherwise) and every pixel of region imaged — the camera's batched backproject on device of each pixel centre in it (Core's pixel_mask convention) finite; an ArgumentError naming who and the count otherwise.
The containment is tested on region itself: Core ≥ 0.10.9 decides RegionIntersection ⊆ Rect by the intersection (the sensor ∩ a housing's image circle whose sensor reaches past the lattice on one axis and circle on the other), so RC 0.11.3's test of the region's bounding box is gone.
RadiometricCamera.coverage_region — Method
coverage_region(camera) -> regionWhere a camera must be defined: the sensor Rect(extent(camera)) ∩ its lens coverage (where light falls) — Core's imaged_region without the model's own valid domain (FOLLOW-UP Core: a public name for it). The region a SplineLens start is resampled over and the coverage assertion (check_coverage) holds the start and the calibrated camera to.
RadiometricCamera.exact_start — Method
exact_start(source::SplineCamera; node_count = nothing, coverage = nothing, device = default_device()) -> (; camera, resample)The start of a SplineLens source (Schöps's lattice, grid.lattice = "derived"), resampled exactly by Estimation's fit_camera(SplineLens, source, region; forward = false) over region = the sensor ∩ the lens coverage (coverage, else the source's: coverage_region): his lattice extended on his own spacing until every node whose support meets the region exists (his present nodes bit for bit, the new ones by Core's bending-energy continuation, marked extrapolated), subdivided by the integer m whose PRESENT nodes over the region come closest to node_count without exceeding it (owner 2026-11-15, 23:25: the target of present nodes doubles as their bound; nothing: m = 1, his own cell — the 40 px subdivision of 0.11.0–0.11.3 cost the 14 mm cases ≈ 9.6 k nodes and a ≈ 200 s host factorisation per LM step; exact_subdivision), Core's exact cubic B-spline knot insertion (the start stays his camera), turned onto his optical axis (Core's exact axis_gauged). The start keeps the full region: a fold of the extension is REPORTED (resample.folds, Core's folded_pixels over the region), nothing trimmed or masked — the refinement may unfold it, and the calibrated camera is checked (calibrated_folds). The lattice is then padded at its right and bottom edges to the grid route's patch multiple (pad_lattice, RC 0.11.2: nodes outside the region, absent but where the region's edge is a knot; the camera unchanged on it). The start is held to the coverage assertion (check_coverage).
resample is the start record's entry (start.json, resample): the start's lattice's grid_size (padded), the subdivision (m_x, m_y), the resulting lattice_spacing (px), the extension_offset (Core's 0-based (row, col) of his first control), extrapolated (the nodes' marks, rows [gy][gx] of the padded lattice; a present padded node marked), padding (from: the resample's own grid_size; nodes: the nodes added per axis; folds: the padded call's report, nothing when none is added), extrapolated_fraction (the share of the region his model images no ray in), folds (folded pixels, samples, unimaged), the fidelity to his rays where he images one (max_px, max_px_edge, rms) and the axis turn (axis_rotation, the rows of R: every control of his is R·c in the start).
RadiometricCamera.grid_angular_error — Method
Largest angular deviation (radians) between the grid's and a reference model's chief rays on an n × n probe grid of the image (the margin of each side, a fraction of the image size, left out), where the grid evaluates (its windows of present nodes).
RadiometricCamera.grid_dims — Method
(G_x, G_y) of a grid lens's grid: Core's grid_size of its geometry.
RadiometricCamera.grid_model — Method
grid_model(src, G_x, G_y; coverage = nothing) -> BoundedCamera{<:CameraModel{<:VgtkCore.AbstractIntrinsics, <:SplineLens}}The SplineLens camera of G_x × G_y controls over the image of the parametric camera src (a SplineLens source is resampled exactly instead, exact_start; Estimation refuses a grid_size for one) by Estimation's public fit_camera(SplineLens, src, imaged_region(src); grid_size = (G_x, G_y), forward = false): the source turned onto its optical axis first (optical_axis, Core's axis_gauged: K's principal point at the axis's pixel — the same camera, its rays rotated), then the backward fitted on Core's full-image lattice of that size to the turned source's rays over its imaged region by the penalized least squares of pspline_grid (one solve, no forward spline; a node the region misses held by the penalty). The camera is bounded by src's image, its lens coverage coverage (the capture set's image region — where light falls, its keyed step's record, never the source lens's fold) or, without one, src's own.
No tolerance is asked of the resample and its fidelity is not reported (Estimation's held-out errors of a resample are not yet right; 2026-11-15). A start whose optical-axis fit did not converge (fit_camera's retcode) proceeds on the lattice fit_camera returned (the stalled axis's rotation 0, as before 0.11.0): the start is not axis-gauged for that run, and one line says so.
RadiometricCamera.in_initialization — Method
in_initialization(detections, region) -> detectionsThe detections (pixel, board point) of detections whose pixel lies in the initialization region (initialization_region, Core's region membership ∈): the ones an initialization step (a pose fit, the self-check) may evaluate the start at. nothing (a parametric start, defined wherever its own valid domain says) keeps them all.
RadiometricCamera.initialization_region — Method
initialization_region(src) -> regionWhere the start camera src (the source a grid start is fitted to: a Schöps run's spline model, a session's camera) is DEFINED: its image ∩ its lens model's valid_domain (Schöps's calibrated area, a Rect2, for its SplineLens) — the region grid_model fits over and the re-gridding's sensor-wide lattice no longer carries. A stage input of the initialization (the run's rc/run_parameters/v1 record holds it), never a camera property: the initialization's steps take it explicitly (in_initialization).
RadiometricCamera.is_grid_lens — Method
Whether l is a grid lens (its nodes are optimised per tile; never a Θ_d block).
RadiometricCamera.region_start — Method
region_start(src, node_count; coverage = nothing) -> (; camera, spacing, origin, supported)A PARAMETRIC start's lattice (the owner's design, 2026-11-15): the SplineLens camera of the parametric camera src on a lattice of square cells laid over the bounding box of the image region — the sensor ∩ the lens coverage coverage (the capture set's image region; nothing, src's own: coverage_region) — whose cell (region_spacing, an integer px) makes the nodes the region supports (Core's present-node rule, node_mask) come nearest node_count. Its controls are Estimation's public fit_camera(SplineLens, src, imaged_region(src); grid_size, forward = false) (the source turned onto its optical axis, the penalized least squares of pspline_grid, as grid_model) on the source in the pixels of the lattice's box, moved back; the nodes the region does not support are ABSENT (never read on it, never a parameter); then the lattice is padded at its right and bottom edges to the grid route's patch multiple (pad_lattice). spacing (px), origin (the pixel where the lattice's area begins: its first node + one cell) and supported (the nodes the region supports, before the padding) describe the lattice.
RadiometricCamera.start_grid — Method
start_grid(source, grid::GridOptions; coverage = nothing, device = default_device()) -> (; camera, resample)The grid start of a source camera, by its TYPE and the lattice's mode grid.lattice: a SplineLens source (a Schöps run's model) under "derived" is resampled EXACTLY on its own lattice, m = 1 (exact_start); a parametric source under "node_count" has its lattice laid over the image region and fitted at grid.node_count supported nodes (region_start; resample = nothing). The other two combinations are refused, naming the key and the fix (a TOML value the input makes unusable is an error, never ignored). coverage: the run's lens coverage (its measured image region; nothing, the source's own).
RadiometricCamera.lens_type_name — Method
The display name of a parametric model's lens (a label of reports and run names): Core's lens_label.
RadiometricCamera.load_camera — Method
load_camera(spec) -> cameraThe bounded Core camera of a model spec (as load_model's), every record as it is: grid: the record's camera (IO's load(BoundedCamera, …): a bounded SplineLens camera), lens: the record's pixel camera, schoeps: a Schöps run's spline model as IO reads it (a bounded SplineLens camera) — the object Core's backproject and backproject_with_jacobian(camera, 𝐩) take.
RadiometricCamera.load_grid — Method
load_grid(path) -> BoundedCamera{<:CameraModel{<:VgtkCore.AbstractIntrinsics, <:SplineLens}}The central grid camera of a VisualGeometryToolkitIO record (load(BoundedCamera, path)): a camera store's SplineLens camera, an old vgio/generic_camera file through IO's read migration (never rewritten: its nominal pinhole the K, its domain the lens coverage).
RadiometricCamera.load_lens — Method
load_lens(spec) -> BoundedCameraThe lens of a model spec that names a record: grid:<record> (a grid camera, load_grid) or lens:<record> (a camera record: Core's pixel camera). The start of a refinement (io.init of the pipeline options).
RadiometricCamera.load_model — Method
load_model(spec, W, H) -> (unp, label)unp(𝐩::SVector{2}) = unit direction of the COLMAP pixel position 𝐩, or nothing where the model is undefined. Specs: grid:<record> | lens:<record> (a camera record: a parametric model, e.g. BlobBoards' division camera of a session's camera.json) | schoeps:<dir or yaml>.
RadiometricCamera.load_parametric_lens — Method
load_parametric_lens(path) -> cameraThe one camera of a VisualGeometryToolkitIO camera record: load(BoundedCamera, path), the pixel camera of its image.
RadiometricCamera.load_start — Method
load_start(spec) -> (; lens, init_region)A stored start (io.init, load_lens's spec) and its initialization region: lens: a parametric camera, defined wherever its own valid_domain says (init_region nothing); grid: a grid camera the pipeline wrote (a result, a saved initialization or a checkpoint), with its initialization region from the record beside it (initialization_region.json, stored_initialization_region) — never the sensor by default.
RadiometricCamera.save_grid — Method
save_grid(path, lens; provenance = (;))A grid lens as VisualGeometryToolkitIO's camera record (vgio/cameras/v6.0, one camera :cam; IO 0.10's one camera kind holds any bounded camera): the bounded SplineLens camera — its K, the lens's {"spline": …} body (the nodes it holds) and its lens coverage.
RadiometricCamera.save_lens — Method
save_lens(path, camera; provenance = (;))A parametric model (Core's pixel camera) as VisualGeometryToolkitIO's camera record (vgio/cameras/v6.0, one camera :cam): K in COLMAP pixels, the lens Core's lens with its own type and coefficients, the image's bound and the lens coverage. provenance: the run's labels (the model's name, the iteration, …).
RadiometricCamera.schoeps_gridlens — Method
schoeps_gridlens(yaml, W, H; coverage = nothing, device = default_device()) -> BoundedCamera{<:CameraModel{<:VgtkCore.AbstractIntrinsics, <:SplineLens}}A Schöps run's central spline model (VisualGeometryToolkitIO's reader: a SplineLens camera, K its lattice's gauge) over the W × H image (its own) resampled EXACTLY by exact_start: his lattice extended over the sensor ∩ the lens coverage (coverage, the run's image circle; else his own) on his own spacing, never subdivided, turned onto his optical axis.
RadiometricCamera.schoeps_run_file — Method
schoeps_run_file(dir, what) -> StringThe file of the Schöps run dir that holds what (:camera or :detections): the run's IMPORT when it has one — camera.json / detections.json, VisualGeometryToolkitIO records in the raw grid's COLMAP pixels, written by a front-end stage that imported the tool's run onto the raw grid (the experiments' scripts/frontends.jl; through its decode's frame map) — else the tool's own file, intrinsics0.yaml / dataset.bin. IO's loaders read either form by its content (load(BoundedCamera, …), load(TargetObservations, …)), so every reader of a run takes its file from here.
RadiometricCamera.schoeps_start — Method
schoeps_start(yaml, W, H; coverage = nothing, device = default_device()) -> (; lens, init_region, resample)schoeps_gridlens's grid start lens, the source's initialization_region init_region (Schöps's calibrated area: where his model is defined) and the resample's record resample (exact_start).