Local optimization strategies

Every strategy implements VisualGeometryToolkitCore's local-optimization contract (lo_workspace, locally_optimize!), so it composes with any scorer in VisualGeometryToolkitEstimation's ransac and find_* pipelines. The core baselines, nothing (no local optimization) and Irls{K}, live in VisualGeometryToolkitEstimation. A width-carrying strategy takes efficiency_constant = m (a multiple of the consensus set's scale), loss_width = w (an absolute width), or neither, in which case its loss width follows the scorer's decision_boundary. See the Overview.

Half-quadratic lifts and graduated non-convexity

LocalOptimizationDoneRight.HQ — Type
HQ{K<:AbstractLossShape} <: AbstractOptimizationStrategy

Joint half-quadratic local optimization of the model and per-point weights under the robust loss K.

Half-quadratic lifted local optimization on loss K (Zach 2014): the genuine joint-(θ,z) Gauss-Newton on the lifted residual (zᵢ·rᵢ, κ(zᵢ²)) with the loss's closed-form Geman–Reynolds regularizer (lift_zblock, VGC's loss family). Per-point weight zᵢ is a free variable, initialized LARGE (all-inlier = smoothed cost) and evolved jointly with θ, Schur-eliminating Δz — this broadens the basin, escaping a poor seed where the static Irls/StudentTUniform is trapped, without annealing or quadrature. ONE code path for every loss AND every problem (ManifoldLiftHQ on VisualGeometryToolkitCore's chart-rows contract, lift/lifts.jl); K contributes only its closed-form z-block quantities and tracked cost. Implemented for every liftable problem (the MinimalSolveProblem family: its lift provider supplies the chart).

The loss width is frozen at setup by the width mode (VisualGeometryToolkitCore's loss_at): at the consensus set's Student-t scale ŝ the efficiency_constant is the PLAIN multiple for every loss (as for Irls{K}), so the loss width is efficiency_constant·ŝ and sq_loss_width is efficiency_constant²·ŝ², with the multiple and the noise variance stored apart and never multiplied into a stored width:

  • K = WelschShape: loss_width = efficiency_constant·ŝ (1.5 was the pre-anchoring point)
  • K = SmoothTLSShape: hard cutoff loss_width = efficiency_constant·ŝ (historically 2.0 = the statistically natural 2σ cutoff; no width follows the scorer's decision point). Default max_iter = 40 (historical ψ̂ arm).
  • K ∈ {GemanMcclureShape, CauchyShape}: loss_width = efficiency_constant·ŝ too. The half-weight currency these losses were once read in is retired (robust contract, 2026-11-11): a value stated as a half-weight depth m_½ is converted once, efficiency_constant = decision_width(K(), m_½) (the roster's GM arms compose it into their grid map; the identity for Cauchy).

Fields

  • max_iter::Int: max joint-GN iterations (25; 40 for SmoothTLSShape)
  • μ::Float64=1e-9: Gauss-Newton damping
  • init::Symbol=:flat: z₀ policy — :flat (all-in, default) | :posterior (soft seed weights) | :consensus (hard r½ mask)
  • width::W: the width mode (efficiency_constant = m, the plain multiple, loss_width = w, or neither: follow the scorer), as Irls
source
LocalOptimizationDoneRight.WelschHQNewton — Type
WelschHQNewton(; efficiency_constant, max_iter=25, μ=1e-9)

Welsch half-quadratic lift refined with the convexified Newton joint-(θ,z) step (Zach & Bourmaud, ECCV 2018, Eq. 15) instead of the Gauss-Newton step of HQ{WelschShape}. Identical fixed-scale setup (loss_width = efficiency_constant·ŝ from the seed partition); the only difference is the second-order z-block with the convexification h_z = max(2r² + 4·loss_width²·(1+ln z), 8r²). Intended as the A/B partner of the GN lift — it should match on easy seeds and (per the paper) reach better minima on hard, barrier-crossing seeds. EssentialProblem only.

source
LocalOptimizationDoneRight.WelschHQEcm — Type
WelschHQEcm <: AbstractOptimizationStrategy

Ablation sibling of HQ{WelschShape}: the same closed-form Welsch joint-(θ,z) lift, but the loss width efficiency_constant·√ŝ² is re-estimated each iteration by the same Student-t + uniform ECM the mixture uses (_mix_ecm), instead of fixed at the seed. Closed-form κ² ⇒ no LUT, so the only added cost is the O(n) ECM sweep. Kept a separate LO strategy so fixed-vs-ECM scale can be ablated head-to-head.

Fields

  • max_iter::Int=25: max joint-GN iterations
  • efficiency_constant::Float64: the loss width as a multiple of ŝ (efficiency_constant·√ŝ², ŝ² re-estimated per iter)
  • μ::Float64=1e-9: Gauss-Newton damping
source
LocalOptimizationDoneRight.BarronHQ — Type
BarronHQ(α; efficiency_constant, max_iter=25, μ=1e-9)

The joint half-quadratic lift of HQ on Barron's loss at a fixed shape α.

The α-DIAL lift (smooth-and-lift 3-ii): the same genuine joint-(θ,z) half-quadratic lift as HQ with the Barron family loss at fixed shape α, standardized at a FIXED CORE WIDTH — the facet-B Barron loss width is efficiencyconstant·ŝ (a value stated in the retired m/√2 currency is migrated once, ×1/√2), which holds the near-zero (Gaussian-core) curvature IDENTICAL across every α, so the dial isolates tail steepness (retirement profile) only. Anchor identities (mandatory gates, liftlossestests.jl): α → −∞ runs the SAME iteration as `HQ{WelschShape}(; efficiencyconstant = √2·efficiency_constant)`; α = −2 matches the GM lift and α = 0 the Cauchy lift at their convention-mapped scales. Runs on the generic ManifoldLiftHQ driver, so on every liftable problem.

source
LocalOptimizationDoneRight.GmHqEps — Type
GmHqEps(; efficiency_constant | loss_width, max_iter = 40, μ = 1e-9)

The Geman–McClure joint-(θ,z) half-quadratic lift, parameterized by its loss width: a research arm beside HQ{GemanMcclureShape}, which standardizes the same loss at its half-weight radius instead.

The loss (VisualGeometryToolkitCore's GemanMcclureShape) is a soft-tailed redescender with a closed-form lift and a constant z-block Hessian; its tail decays polynomially and never reaches zero weight. At loss width w the half-weight radius is √(√2 − 1)·w ≈ 0.6436·w.

The loss width is efficiency_constant·ŝ (ŝ the consensus set's scale) or an absolute loss_width in the residuals' units; give at most one. With neither, the loss follows the scorer: its half-weight radius sits at the scorer's decision_boundary (a loss width of about 1.554 times it). max_iter bounds the joint Gauss–Newton iterations and μ is their damping; the defaults are configs/default.toml's [optimization_strategy.gm_hq_eps]. It runs on the generic lift driver, so on every liftable problem, and like every local optimizer it can end in a local minimum of its seed's basin.

source
LocalOptimizationDoneRight.Gnc — Type
Gnc{S<:AbstractOptimizationStrategy} <: AbstractOptimizationStrategy

Graduated non-convexity over the objective of the static strategy S.

Graduated-non-convexity WRAPPER: canonical Yang–Carlone GNC (RA-L 2020) with the Black–Rangarajan surrogate weights, graduating the objective of the wrapped static strategy S — the paper's three GNC baselines for the continuation family:

  • Gnc{Irls{WelschShape}} — GNC-W (annealed-width Welsch)
  • Gnc{Irls{TLSShape}} — GNC-TLS (Black–Rangarajan band surrogate of the HARD truncation; TLSShape is the hard-TLS facet tag of VGC's loss family)
  • Gnc{Irls{GemanMcclureShape}} — GNC-GM (μ-convexified GM)

The type parameter ADMITS any strategy (Gnc{HQ{K}} — graduation OVER the lift, a composite :gnc ∘ :hq mechanism — and the Resample{S} wrapper are NOT implemented here, the LO dispatch covers Gnc{<:Irls} only). The GNC arms run through the same locally_optimize! contract as every IRLS/lift strategy — one code path, one width resolution.

Width (VisualGeometryToolkitCore's loss_at): under EfficiencyConstant(m) the terminal (target) loss width is c̄ = m·ŝ with ŝ the consensus set's Student-t scale (exactly the width the lifted loss arms freeze); under LossWidth(w) it is w; with neither it follows the scorer's decision_boundary. There is no plug-in scale bootstrap.

Variants and μ-schedules:

  • :gm (GNC-GM) — surrogate ρμ(r) = μc̄²r²/(μc̄² + r²), weights `w = (μc̄²/(r² + μc̄²))² ≡ liftweight(GM, r², μ·c̄²)`; μ₀ = 2·r²_max/c̄² (convex start from the SEED residual extreme), μ ← μ/factor per rung, clamp at μ = 1 (true GM) and spend the remaining budget there.
  • :welsch (GNC-W) — annealed-WIDTH Welsch, c²μ = μ·c̄², weights w = exp(−r²/(μc̄²)); μ₀ = r²max/c̄² (every seed point starts ≥ e^{−1}) or a numeric entry = m ⇒ μ₀ = max(m², 1) (entry-breadth dose axis), μ ← μ/factor, clamp at μ = 1 (target Welsch at c̄).
  • :tls (GNC-TLS) — piecewise Black–Rangarajan band weights (gnc_tls_weight); μ₀ = c̄²/(2r²max − c̄²) with the r²max ≤ c̄²/2 guard (⇒ skip graduation, start effectively-hard), μ ← factor·μ, stop graduating once the middle band is empty or μ ≥ 1e6, then finish at the terminal surrogate.

Budget parity: TOTAL model updates across ALL rungs = max_iter (the shared 25-update LO cap; every GNC stage counts). Rung arithmetic is VGC MuLadder (budget = :converged ⇒ converged-rung mode, max_iter a safety ceiling). Rung advance is scheduled OR stall-early; termination is TERMINAL-only (the 373d0a6 semantics via the LoSchedule trait). Best-tracking is on the TARGET loss (true TLS cost / true GM ρ / fixed-width Welsch cost at c̄) — graduation shapes exploration only. Implemented for every liftable problem (the MinimalSolveProblem family), like HQ{K}.

source

Student-t + uniform and Barron-adaptive strategies

LocalOptimizationDoneRight.StudentTUniform — Type
StudentTUniform <: AbstractOptimizationStrategy

The paper's Stu-tU-IRLS: posterior-weighted IRLS under the Student-t + uniform mixture (the same model family as the profile-marginal score). Computes posterior inlier probabilities from the marginal score partition, uses them as soft weights for a WLS refit, re-scores, and iterates over a fixed Student-t + uniform likelihood. Self-scaling: it re-estimates its own scale each iteration (contrast with the consensus-anchored Irls{K}/HQ{K}/ Gnc{S} strategies, whose loss width is frozen at efficiency_constant·ŝ from the consensus set).

It needs the scorer's uniform outlier model (outlier_halfwidth).

Fields

  • max_iter::Int=5: Max IRLS iterations per hypothesis
source
LocalOptimizationDoneRight.StuTuBCD — Type
StuTuBCD <: AbstractOptimizationStrategy

Exact same-objective refinement for VisualGeometryToolkitCore's StudentTUniformScoring: block-coordinate ascent on the scoring objective S itself. Alternates

(model) θ⁺ = argminθ Σ{i∈I} rᵢ(θ)² — hard-inlier least squares (partition) I⁺ = argmax_I S(θ⁺, I) — the score's own sort-and-sweep

to convergence. Every step is non-decreasing in S: the model step lowers RSS_I with all other score terms fixed (so S rises), and the partition step is the score's exact argmax over partitions. Unlike StudentTUniform (soft, score-derived responsibilities under a related t/uniform mixture — NOT the Jeffreys-collapsed hard-partition objective) and the Welsch-HQ lift (a different objective optimized jointly over auxiliary weights), this is the strict same-objective' baseline: exact score monotonicity, hard partition. Expected to be very monotone but narrow-basined — correspondences excluded by the current partition exert no force on the pose (RSS_I` sees only I).

Fields

  • max_iter::Int=25: max block-coordinate sweeps per hypothesis
  • tol::Float64=0.0: minimum score increase to keep iterating
source
LocalOptimizationDoneRight.StuTuHQTabulated — Type
StuTuHQTabulated <: AbstractOptimizationStrategy

Half-quadratic lifted LO using the exact Student-t + uniform mixture loss ρ(r)=−log(π_in t_ν(r;ŝ²)+π_out(2a)^{−d}). Same genuine joint-(θ,z) weight-lift as HQ{WelschShape}, but the regularizer κ² — whose closed form is transcendental for the mixture — is tabulated per ECM iteration: the monotone weight ω=u·w_resp is inverted on a grid (r²(w)=−κ²′(w)) and cumulatively integrated (κ²(w)). Scale ŝ² and mixing π_in are ECM/EM-updated each iteration. EssentialProblem only.

The lifting-regularizer strength γ scales the down-weighting penalty κ² (a GNC-style continuation knob): γ>1 makes the lift more reluctant to switch points off (softer z-block Hessian, hreg ∝ 1/γ), keeping it in a smoother, wider-basin regime for better escape from a poor seed. Selection is always on the true γ=1 objective (best-tracking), so γ shapes only the exploration — hence a constant, validated γ (rather than a schedule). κ² is built on a fine grid so γ is the sole, explicit regularizer knob. On PT val the LO is insensitive to γ over [1,5] (median 4.92–5.04°, within the basin-flip noise); γ=2.5 is the robust plateau choice (near the per-scene minima, non-edge).

Fields

  • max_iter::Int=25: max joint-GN iterations
  • γ::Float64=2.5: lifting-regularizer strength (PT-val plateau; LO is γ-insensitive over [1,5])
  • μ::Float64=1e-9: Gauss-Newton damping
  • lut_points::Int=32: κ² grid resolution. The table is read by cubic Hermite interpolation using the exact node slopes κ²′=−r² (the stationarity condition), so 32 nodes match a ~1000-node linear table in accuracy at ~⅛ the per-iteration rebuild cost. γ remains the sole regularizer knob — grid coarseness is no longer an accuracy lever (the inflation trap of a coarse linear table is avoided).
source
LocalOptimizationDoneRight.StuTuRegemm — Type
StuTuRegemm <: AbstractOptimizationStrategy

Half-quadratic LO for the same Student-t + uniform mixture loss as StuTuHQTabulated, but solved by relaxed generalized majorization-minimization (ReGeMM; Zach & Le, ECCV 2020, §6.1) instead of the joint weight-lift. Faithful to the paper's robust-estimation scheme: weights are initialized all-inlier (u≡1) and inferred inexactly by graduated non-convexity. Each round (i) ECM-updates ŝ²,π_in and rebuilds the κ² table, (ii) sets uᵢ = ω(rᵢ/σ) — the touching weight at an inflated scale σ≥1, with σ the largest value (by bisection) still meeting the diminishing-gap criterion J(θ,uⁿᵉʷ) ≤ η·J(θ) + (1−η)·J(θ,uᵒˡᵈ), J(θ)=minₚ J(θ,u), then (iii) minimizes the bound over the pose for the graduated weights (the weighted-Sampson refit, Alg. 1's line-3 argmin), accepted only if it descends. σ anneals to 1 as the gap tightens, so this is weight-space GNC from the smooth init.

The monotone, convergent counterpart of the StuTuHQTabulated joint step. Zach & Le report it favorable vs the joint HQ lift on bundle adjustment (truncated quadratic); on 2-view essential the joint lift reaches a better optimum with a lighter tail. EssentialProblem only.

Fields

  • max_iter::Int=100: number of ReGeMM rounds (one σ-graduation + one pose refit each)
  • η::Float64=0.5: diminishing-gap fraction (Zach & Le use η=1/2; η→1 ⇒ touching/standard MM = IRLS)
  • lut_points::Int=128: κ² lookup-table resolution
source
LocalOptimizationDoneRight.BarronAdaptive — Type
BarronAdaptive(; efficiency_constant | loss_width, max_iter=25, α_min=-10.0,
               truncation_multiple=10.0, n_sub=256)

IRLS on Barron's loss whose shape is re-estimated from the residuals each iteration.

Solver-matched ADAPTIVE-SHAPE robust IRLS: the identical PosteriorIrlsMethod/block_coordinate_descent! machinery as StudentTUniform / Irls{WelschShape}, with Barron's generalized loss ρ(r; α, losswidth) (CVPR 2019) whose SHAPE α is re-estimated each iteration from the current residuals by minimizing the truncated-partition negative log-likelihood of Chebrolu et al. (RA-L 2021, Eq. 11-15): 1-D grid search over α ∈ [αmin, 2], with Z̃(α) = ∫_{-T}^{T} e^{-ρ(x, α, 1)} dx, T = truncation_multiple (the normaliser's domain, in units of the loss width). The loss width is efficiency_constant·ŝ, frozen at the seed partition's Student-t scale — Chebrolu et al. fix the width for exactly the scale/shape confounding our partition anchor resolves. n_sub caps the residual subsample used by the α grid search (strided; the full set is used when n ≤ n_sub).

This is the "adaptive-static" cell of the loss taxonomy: the loss adapts its shape within the solve (no lift, no graduation) — the strongest representative of "why not adapt instead of lift?".

source
LocalOptimizationDoneRight.BarronAdaptiveLikelihood — Type
BarronAdaptiveLikelihood <: AbstractWeightPolicy

Likelihood adapter for BarronAdaptive. update_nuisance! is the α-step (Chebrolu Alg. 1 step 1): grid-argmin over α of log Z̃(α) + mean ρ(rᵢ/c; α) on the (strided) residual subsample. update_weights! sets the Barron IRLS weights at the current (α, c). Only the SHAPE α moves here; the WIDTH is frozen at construction from the arm's (efficiency_constant, ŝ²) pair (sq_loss_width) and is stored as its reciprocal because the unit-scale α math divides by it.

source

PoseLib truncated refiners

External refiners (VisualGeometryToolkitCore's ExternalRefit): they refine a seed at an absolute loss width through refine_external!, outside the RANSAC loop. The solver calls load with PoseLib (a package extension). See Baselines.

LocalOptimizationDoneRight.PoseLibLm — Type
PoseLibLm(max_iter) <: AbstractOptimizationStrategy

PoseLib Levenberg–Marquardt over the TRUNCATED Sampson loss (TLSShape) — the LO-RANSAC standard truncated refiner (TLS-IRLS). An external refiner (ExternalRefit): it refines at an absolute loss width (refine_external!), not in the native RANSAC loop. max_iter is its LM budget.

source
LocalOptimizationDoneRight.PoseLibLmAdaptLossWidth — Type
PoseLibLmAdaptLossWidth(; max_iter, rounds, efficiency_constant)

PoseLib's truncated LM refiner with its loss width re-estimated between rounds.

Consensus-anchored truncated refit (TLS-IRLS-ŝ): PoseLib LM over the truncated loss, its loss width re-formed between rounds LM rounds as efficiency_constant·ŝ of the current model's within-width residual scale (outer pose-block / scale-moment alternation; PoseLib is a black box).

The INITIAL width is anchored on the seed's consensus scale — ŝ² of the consensus set under the refit scoring at the outlier half-width of the delivered loss width (loss_width_to_outlier_halfwidth at the refit protocol's operating efficiency constant, [optimization_strategy.poselib_adapt] operating_efficiency_constant), VisualGeometryToolkitEstimation's consensus_s2! — never a plug-in scale; a consensus too thin to carry a scale makes no refit. max_iter is the total LM budget across rounds. Defaults: configs/default.toml [optimization_strategy.poselib_adapt]. E-track only (PoseLib refine_relpose).

source
LocalOptimizationDoneRight.truncated_refit_pose — Function
truncated_refit_pose(lo, ws, problem, seed_E, loss_width) -> refined pose

The relative pose a PoseLib truncated refiner reaches from an essential-matrix seed.

The E-branch optimizer body of a PoseLib truncated refiner WITHOUT a guard or scoring bracket: the seed's cheirality-resolved pose (fast strided vote on the problem's bearings) refined by PoseLib refine_relpose at the absolute pool-frame loss_width, on the refiner's external_workspace. For callers that need the REFINED pose itself (a warm-started polish). Implemented by the PoseLib extension.

source

Cross-validated operating points

LocalOptimizationDoneRight.tuning_constant — Function
tuning_constant(problem::Symbol, shape::AbstractString;
                features::Symbol = :any, dataset::Symbol = :any) -> TuningConstant

The cross-validated efficiency constant of a model class and loss shape.

Resolve the cross-validated efficiency_constant for problem (:essential | :fundmat | :homography | :radial_homography | :radial_camera | :absolute_pose) and loss shape (the tag vocabulary a strategy's loss key uses) along the provenance hierarchy (features, dataset) → (features, :any) → (:any, :any).

shape does NOT wildcard. An efficiency constant is an operating point for one shape, not a unit that converts between them, so a class with no entry for the requested shape raises rather than serving a constant validated for a different one. Check .validated to see whether the returned value was cross-validated at its own key or transferred (.transfer names the source key), and .tuning for the product tuning that produced it.

julia> using LocalOptimizationDoneRightjulia> c = tuning_constant(:essential, "welsch");julia> c.efficiency_constant, c.validated   # the class tier holds a transferred value(1.597, false)julia> c.efficiency_constant == WELSCH_HQ_EFFICIENCY_CONSTANT_ESSENTIALtrue
source
LocalOptimizationDoneRight.TuningConstant — Type
TuningConstant

A cross-validated efficiency_constant with codified provenance — the loss width as a multiple of the estimated scale; see VisualGeometryToolkitCore.deploy.

Fields

  • efficiency_constant::Float64 — the loss width as a multiple of ŝ (partition-anchored).
  • shape::String — the loss shape this value was validated for, in the tag vocabulary a strategy's loss key uses ("welsch", "geman_mcclure", …).
  • tuning::TuningProvenance — the product tuning that produced the value (for a transfer: the one that produced the value it borrows).
  • transfer — nothing for a value validated at its own key, else the registry key (problem, features, dataset) it was transferred from.
  • validated::Bool — transfer === nothing (derived, not stated).
source
LocalOptimizationDoneRight.TuningProvenance — Type
TuningProvenance

Where a cross-validated efficiency_constant came from: arm arm of the product tuning [tuning.<name>] of the cell config of record config (a path relative to the directory holding the stack checkouts), whose spec hashes to hash (VisualGeometryToolkitEval tuning_hash). pending_hash is nothing, or the hash the config of record's spec has since moved to: the value is pending re-validation under it (and hash still names the spec that produced it).

source
LocalOptimizationDoneRight.WELSCH_HQ_EFFICIENCY_CONSTANT_ESSENTIAL — Constant
WELSCH_HQ_EFFICIENCY_CONSTANT_ESSENTIAL

The Welsch-HQ efficiency_constant of the essential class.

For VisualGeometryToolkitEstimation.find_essential, it is the deployed optimum of the PT-E-SIFT-4K product tuning (the essential class tier transfers it from the (:sift, :phototourism) entry, the one that tuned it). Equal to tuning_constant(:essential, "welsch").efficiency_constant.

source
LocalOptimizationDoneRight.WELSCH_HQ_EFFICIENCY_CONSTANT_FUNDMAT — Constant
WELSCH_HQ_EFFICIENCY_CONSTANT_FUNDMAT

The Welsch-HQ efficiency_constant of the fundmat class (VisualGeometryToolkitEstimation.find_fundmat). TRANSFERRED from the essential entry — tuning_constant(:fundmat, "welsch").validated is false until the PT-F cross-validation lands.

source
LocalOptimizationDoneRight.WELSCH_HQ_EFFICIENCY_CONSTANT_HOMOGRAPHY — Constant
WELSCH_HQ_EFFICIENCY_CONSTANT_HOMOGRAPHY

The Welsch-HQ efficiency_constant of the homography class (VisualGeometryToolkitEstimation.find_homography). TRANSFERRED from the essential entry — tuning_constant(:homography, "welsch").validated is false until the HEB-H re-CV succeeds at its gate.

source
LocalOptimizationDoneRight.WELSCH_HQ_EFFICIENCY_CONSTANT_ABSOLUTE_POSE — Constant
WELSCH_HQ_EFFICIENCY_CONSTANT_ABSOLUTE_POSE

The Welsch-HQ efficiency_constant of the absolutepose class (`VisualGeometryToolkitEstimation.findabsolutepose). TRANSFERRED from the essential entry — no PnP entry has been cross-validated yet, sotuningconstant(:absolute_pose, "welsch").validatedisfalse`.

source

TOML registry

LocalOptimizationDoneRight.LODR_STRATEGY_TAGS — Constant
LODR_STRATEGY_TAGS

The TOML tags of this package's local-optimization strategies.

This package's local-optimization strategy registry (VisualGeometryToolkitCore's TagRegistry, built by VisualGeometryToolkitEstimation's @lo_registry): TOML tag → strategy type or loss-parametric family, the tag snake_case of the type's name. Retired tags name their successor. Merge it with the core's to load either: merge(VisualGeometryToolkitEstimation.OPTIMIZATION_STRATEGY_TAGS, LODR_STRATEGY_TAGS).

source

Index