S23DR 2026 Winning Solution
Abstract: This text presents the winning solution to the S23DR 2026 challenge for structured 3D wireframe reconstruction from sparse SfM, fitted depth, and semantic segmentations. The method treats vertices as a conditional set and denoises 64 vertex tokens with a flow-matching DiT conditioned on Perceiver-style scene tokens. A global pass predicts the coarse structure, a hull-cropped second pass refines it, and a small multi-sample consensus step keeps the stochastic sampler well behaved. The final system ranked first on the private leaderboard, achievingHSS = 0.654.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
What is this paper about?
This paper explains how a team won a 3D modeling competition (S23DR 2026). The challenge was to draw a clean “wireframe” of a house roof in 3D—like a stick-figure sketch of all the roof corners and straight edges—using only sparse 3D points, estimated depths, and semantic labels (what kind of roof part each point belongs to). No original photos were allowed.
Their method predicts where the roof’s key corners (called vertices) are and which ones connect to form edges. It does this in two passes: first a rough guess over the whole scene, then a focused refinement around the building. Finally, it combines several slightly different tries into one stable answer. This approach ranked first on the private leaderboard with a strong overall score (HSS = 0.654).
What questions did the researchers ask?
They focused on three simple questions:
- From limited, noisy 3D clues (no images), can we recover a clean 3D wireframe of a building roof?
- Is it better to directly “generate” the set of roof corners in 3D, instead of converting 2D predictions into 3D afterward?
- Can a two-step process (coarse guess, then fine tuning) plus a small “voting” step make the results more accurate and less random?
How did they do it?
Think of the system as a careful craftsperson:
- It studies the scene to understand where useful hints are.
- It places a fixed number of “corner candidates” in 3D.
- It nudges these candidates step by step from a noisy start toward the true roof corners, guided by the scene clues.
- It repeats the process more precisely in a cropped area around the building.
- It merges multiple tries into one reliable wireframe.
Here’s what those steps mean in everyday terms.
The data they used
- Point cloud: a scattered set of 3D points from Structure‑from‑Motion (SfM). Imagine a sparse constellation of dots floating where the roof is.
- Depth maps: estimates of how far surfaces are, projected back into 3D points to add more dots.
- Semantic segmentations: labels like “ridge,” “eave,” or “apex” that say what kind of roof part each pixel/point comes from.
The data is messy: few camera views, missing depth in many images, and noise on flat, textureless roof surfaces. Roof designs also vary a lot—from simple gables to complex, multi-level roofs.
Step 1: “See” the scene (the scene encoder)
They first turn all those heterogeneous clues (3D positions, point type, roof-part labels, confidence) into unified feature “tokens.” A model called a Perceiver-style encoder summarizes the whole scene into a fixed set of “scene tokens.” You can think of scene tokens as a compact set of notes that capture the important parts of the roof.
How it helps:
- It lets the system look at all points together (so each token “knows” about nearby and far-away points).
- It anchors some of its attention on important roof-part points (like ridges/eaves), so the summary focuses on what matters.
Step 2: Place and refine the corners (the vertex denoiser)
The system keeps 64 “vertex tokens,” each representing a potential roof corner in 3D. At the start, these are noisy guesses. A Transformer model (a pattern-finding neural network) repeatedly nudges these points in small steps toward better positions. This nudging process is called “flow matching”: imagine guiding each guessed corner along a smooth path from fuzzy to sharp.
Along the way, the model also:
- Decides which tokens are real corners and which should be inactive (validity).
- Predicts which pairs of corners should be connected by straight edges (edge logits).
Important idea: The model doesn’t care about the order of the corners. It learns to match its 64 guesses to the true corners in the best possible way (like pairing socks from a messy pile), so it is “permutation-invariant.”
Two passes: global first, local second
- Pass 1 (Global): Look at the whole scene and predict a coarse set of corners.
- Crop: Build a simple outer shell (convex hull) around those predicted corners, expand it a bit, and focus only on the points inside. This cuts out irrelevant clutter.
- Pass 2 (Refinement): Re-run the corner-nudging steps inside the crop, starting from Pass 1’s results. This allows more precise adjustment.
Voting for a stable answer (ensemble consensus)
Because there’s randomness at the start (the first guess of corner positions), different runs can give slightly different results. To fix this:
- They run the model 16 times with different random starts.
- They select a representative prediction (the “medoid”) and then average the matched corners across the runs to stabilize positions.
- This “multi-sample consensus” reduces variability without changing the basic roof shape.
What did they find?
- Top performance: Their system ranked first on the private leaderboard with a Hybrid Structure Score (HSS) of 0.654, beating the second place (0.648) and clearly outperforming both learned (0.474) and handcrafted (0.391) baselines.
- Strong corner accuracy: It achieved the highest vertex F1 score (0.791), meaning it found the right corners more often and avoided false ones better than others.
- Two-stage helps: Adding the second, cropped refinement pass improved accuracy over using only the global pass.
- Voting helps stability: The 16-sample ensemble made results more consistent and slightly more accurate.
What is HSS? It’s a combined score that rewards getting both the corners and the edges right. It checks:
- Corner matching (Are the predicted corners near the true ones, with the best pairing between them?)
- Edge overlap (Do the predicted connections match the true ones in 3D space?)
Why does it matter?
- Works with limited data: This method succeeds without using the original photos—just sparse 3D points, estimated depth, and labels. That’s useful for privacy or when images aren’t available.
- Robust to messy inputs: The generative “place corners directly in 3D” approach handles noisy, incomplete data better than methods that first predict in 2D and then lift to 3D.
- Practical uses: Accurate 3D roof wireframes can help in mapping, city planning, insurance, architecture, and disaster response (e.g., damage assessment after storms).
- Broader lesson: Treating structures as sets of key points (and learning to nudge them into place) can be a powerful way to reconstruct many kinds of 3D shapes, not just roofs.
In short, the paper shows a clear, effective recipe: summarize the scene, predict a set of corners directly in 3D, refine locally, and stabilize with small-scale voting. This strategy delivers state-of-the-art results on a tough, real-world task.
Knowledge Gaps
Knowledge Gaps, Limitations, and Open Questions
Below is a concise, actionable list of what remains missing, uncertain, or unexplored in the paper; each point can guide follow-up research.
- Adaptive vertex cardinality: The model uses a fixed 64-slot budget despite scenes having 6–36 vertices; investigate adaptive slot counts, learned stopping criteria, or nonparametric set sizes to avoid over/under-allocating capacity.
- Stage-2 recoverability: The hull-cropped refinement cannot recover vertices missed by Stage 1 if they fall outside the inflated convex hull; explore mechanisms to add new vertices in Stage 2 (e.g., dynamic cropping, out-of-hull expansion heuristics, proposal modules).
- Edge semantics: The system predicts pairwise edge logits but does not describe modeling or predicting edge semantic classes; assess explicit edge class prediction and its impact on HSS or downstream uses.
- Topology/geometry constraints: No explicit constraints enforce valid roof grammar (e.g., planarity of faces, manifoldness, vertex degree priors, orthogonality/parallelism); study constrained decoding or post-hoc projection to valid architectural topology.
- Loss–metric mismatch: Training optimizes velocity/endpoint/validity/BCE losses while evaluation uses HSS (vertex F1 + volumetric IoU on cylindrical edges); develop differentiable surrogates or direct HSS-oriented training (e.g., differentiable edge rendering, topology-aware losses).
- Uncertainty calibration: Ensemble consensus reduces variance but yields no calibrated per-vertex/edge uncertainties; evaluate Bayesian or ensembling-based calibration, predictive intervals, and uncertainty-aware graph selection.
- ODE solver design: Inference uses 50 Euler steps; analyze solver choice (Heun, RK), step schedules, error control, and ODE vs SDE formulations for stability–quality trade-offs.
- Flow-matching schedule: Only linear interpolants are used; examine alternative couplings/schedules for flow matching, time sampling strategies, and their effect on convergence and accuracy.
- Point sampling and anchors: Priority-tier sampling (8192/16384 points) and “priority-aware Gestalt FPS” anchoring lack ablations; quantify sensitivity to budgets, tiering, anchor selection algorithms, and assess learned/dynamic pooling.
- Robustness to missing modalities: With high depth-map sparsity (up to 69% of validation views pose-only), the method’s robustness to modality dropout is unquantified; test modality-agnostic training, stochastic modality dropping, and learned fusion.
- Segmentation noise: 2D semantic projections and neighborhood voting are noisy; study joint denoising, soft-label/uncertainty propagation, or co-training segmentation with reconstruction.
- Domain generalization: Trained on residential HoHo; evaluate transfer to non-residential, multi-story, flat/curved roofs, regional styles, and different sensor setups (e.g., UAV altitudes).
- Scale/orientation normalization: The pipeline centers by median and scales by a robust radius; test sensitivity to mis-centering, rotation/scale variations, and incorporate SE(3)-equivariant encoders or augmentation strategies.
- Graph thresholding: The paper does not specify edge/validity threshold selection or calibration; analyze threshold calibration, temperature scaling, and structured decoding for stable graph construction.
- Data efficiency: Training for 2000+1000 epochs on 4×H200 is compute-heavy; explore self-supervised pretraining on point clouds, synthetic data augmentation, curriculum learning, and distillation to smaller models.
- Failure modes: No systematic failure-case analysis; categorize typical errors (missed eaves/rakes, over-smoothing, spurious edges in clutter) and link them to input conditions to guide targeted fixes.
- Preprocessing dependency: Performance depends on cached semantic point clouds; evaluate end-to-end integration, sensitivity to preprocessing errors, and methods to jointly optimize preprocessing and reconstruction.
- Stage-2 bootstrapping bias: Stage 2 is trained on crops initialized from Stage-1 predictions; analyze robustness to poor Stage-1 outputs and consider teacher–student or joint iterative training to reduce compounding bias.
- Ensemble design: Only medoid + consensus averaging with 16 samples is reported; examine sample count vs. accuracy, diversity-aware selection, learned ensembling, and test-time optimization to cut compute.
- HSS edge rendering radius: Training ignores the cylindrical rendering radius used in HSS IoU; study training objectives that reflect the evaluation geometry (radius-aware losses or differentiable volumetric overlap).
- Scene encoder capacity: A fixed 1024 scene-token bank (d=320) is used without multi-scale or hierarchical schemes; assess hierarchical pooling, dynamic token counts, and long-range/short-range balance.
- Gestalt FPS details: “Priority-aware Gestalt FPS” is not fully specified; formalize the algorithm, justify priority weighting, and ablate alternative selection strategies (e.g., density-aware, uncertainty-aware anchors).
- Clutter/outliers: Cropping reduces far-field clutter but robustness to near-field clutter (vegetation, HVAC units) is unquantified; design outlier-aware attention, robust loss functions, or clutter segmentation.
- Multi-building scenes: The dataset has single-building scenes; evaluate scalability to parcels with multiple structures or dense urban blocks and devise instance separation mechanisms.
- Real-time and resource constraints: Inference takes ~5.5s/scene with ensemble; explore acceleration (fewer steps, lighter backbones, early exit), quantization, or distillation for deployment.
- Parameter efficiency vs. accuracy: No trade-off curve is presented for model size/latency; conduct systematic scaling and pruning studies to identify sweet spots.
- Seed sensitivity: While ensemble reduces variance, per-run variance is not quantified; report seed variance for single/ensemble settings and devise stabilization techniques beyond ensembling.
- Structured edge losses: Pairwise BCE for sparse adjacency is highly imbalanced; test focal/contrastive/metric-learning losses or structured (CRF/ILP) training for graph sparsity and consistency.
- Dynamic vertex addition/deletion: Validity logits toggle slots, but no mechanism encourages the “right” vertex count; incorporate count priors, Poisson/MDL penalties, or birth–death processes for sets.
- Autoregressive vs. conditional set generation: The choice is not compared; benchmark autoregressive or diffusion-with-matching alternatives for topology fidelity and training stability.
- Photometric cues: RGB is unavailable; study privacy-preserving photometric features (e.g., learned features from anonymized or stylized images) or synthetic RGB to assess potential gains without violating privacy.
- Reproducibility details: Exact thresholds, data augments, and post-processing hyperparameters are under-specified; publish configs, seeds, and ablations to ensure replicability.
Practical Applications
Immediate Applications
Below are deployable applications that leverage the paper’s two-stage, Perceiver–DiT flow-matching pipeline for structured 3D wireframe reconstruction from sparse SfM, fitted depth, and semantic segmentations.
- Automated roof modeling for insurance triage and claims
- Sectors: Insurance, Emergency management
- Use cases: Rapid post-storm roof geometry extraction for claim pre-approval, identifying ridge/eave damage lines, pre-site estimates without sending adjusters
- Tools/products/workflows: Drone-to-wireframe workflow; “RoofWireframe API” integrated into claims platforms; automated PDF reports with edge classes (rake/eave/valley) and confidence
- Assumptions/dependencies: Adequate segmentation and metric depth per view; limited occlusions; domain shift from training (residential) to local housing stock; latency trade-off if ensemble (16×) is used
- Solar PV pre-design and quoting
- Sectors: Energy (solar), Home services
- Use cases: Estimating usable roof planes, slope/azimuth, ridge/valley constraints, obstruction-aware string sizing before a site visit
- Tools/products/workflows: “Solar layout assistant” converting wireframes to planar facets; integration with irradiance simulators; web estimator widgets
- Assumptions/dependencies: Accuracy of eave/ridge heights; segmentation quality near roof edges; acceptance of 5–10 cm vertex error tolerance for quoting (not final engineering)
- GIS/cadastral roof footprint and ridge-line extraction
- Sectors: Government, GIS/Mapping, Urban planning
- Use cases: Updating parcels with roof footprints, ridge network layers, runoff modeling, snow-load zones
- Tools/products/workflows: QGIS/ArcGIS plugin exporting wireframe edges as shapefiles/GeoJSON; batch processing of drone captures
- Assumptions/dependencies: Robust metric scaling from SfM/depth; compliance with municipal accuracy standards; sufficient view coverage
- Drone inspection pre-BIM seeding
- Sectors: Architecture, Engineering, Construction (AEC)
- Use cases: Seeding BIM roof objects from sparse flights for renovation, as-built verification, and clash-prevention planning
- Tools/products/workflows: “Drone-to-BIM seed” exporting IFC/OBJ with labeled edges; plugin for Revit/Archicad to snap parametric elements to predicted vertices
- Assumptions/dependencies: Mapping Gestalt/ADE classes to BIM taxonomies; human-in-the-loop cleanup; reliable hull-cropped refinement on complex roofs
- Privacy-preserving municipal surveys
- Sectors: Public policy, Municipal services
- Use cases: Collecting structural roof data while discarding RGB imagery; audits for solar mandates or zoning roof-pitch limits
- Tools/products/workflows: On-device segmentation and depth to produce semantic point tokens; storage of only wireframes and metadata
- Assumptions/dependencies: Legal acceptance of derived data as evidence; reliable on-device segmentation; policy frameworks permitting RGB discard post-processing
- Telecom RF planning obstacle modeling
- Sectors: Telecommunications
- Use cases: Incorporating roof ridges/eaves as obstructions in ray-tracing and line-of-sight planning for small cells
- Tools/products/workflows: Export to RF planners (e.g., .obj/.dxf layers with class labels); automated obstruction cataloging
- Assumptions/dependencies: Height accuracy within RF simulation tolerances; urban clutter not modeled beyond roofs
- Academic benchmarking of conditional set generation and graph metrics
- Sectors: Academia, Research
- Use cases: Studying flow matching for geometric graphs, permutation-invariant training via Hungarian assignment, evaluating with Hybrid Structure Score (HSS)
- Tools/products/workflows: Reference training recipe (34M params, DiT-based denoiser), ablations on ensemble consensus, public validation sanity script
- Assumptions/dependencies: Access to similar datasets (or synthetic data); compute (multi-GPU) for training; fair-use of segmentation models (ADE/roof Gestalt)
- Photogrammetry/GIS software plugin
- Sectors: Software, Robotics/SLAM
- Use cases: One-click “Build roof wireframe” inside COLMAP/OpenMVG pipelines; overlaying wireframes on point clouds for QA
- Tools/products/workflows: Lightweight inference service (with optional reduced ensemble for latency); GUI integration; batch CLI
- Assumptions/dependencies: GPU availability for attention models; stability on sparse/noisy SfM; segmentation and depth pre-processing steps
Long-Term Applications
These applications require additional research, domain adaptation, scaling, or tighter system integration before broad deployment.
- Full parametric BIM generation from sparse captures
- Sectors: AEC, Digital twins
- Use cases: Auto-generating parametric roof families (hips, valleys, mansards) and wall lines from a single drone pass
- Tools/products/workflows: Learned wireframe-to-parametric fitting; uncertainty-aware snapping; automatic plane extraction and topology checks
- Assumptions/dependencies: Robust generalization beyond residential roofs; codified mappings from edges to parametric primitives; tighter error bounds
- City-scale digital twin updates from crowd-sourced or agency flights
- Sectors: Government, Urban planning, Insurance consortia
- Use cases: Continuous updates of building models for taxation, climate adaptation, and infrastructure planning
- Tools/products/workflows: Scalable orchestration (Spark/Ray) for batch inference; data governance pipelines; change detection from wireframe diffs
- Assumptions/dependencies: Standardized capture protocols; compute budgets; policies for privacy-preserving processing and data retention
- Onboard real-time wireframe reconstruction for autonomous drones/robots
- Sectors: Robotics, Inspection, Public safety
- Use cases: Adaptive path planning along roof ridges/eaves; safety geofencing; autonomous inspection with structural awareness
- Tools/products/workflows: Model distillation/quantization; reduced-step solvers (fewer Euler steps); hardware acceleration (Jetson, NPUs)
- Assumptions/dependencies: Real-time semantic segmentation & depth on edge; robustness to motion blur/low light; reduced ensemble without compromising stability
- Generalization to diverse structures (bridges, industrial plants, facades)
- Sectors: Infrastructure, Manufacturing
- Use cases: Wireframe abstractions for inspection planning, corrosion monitoring, and maintenance scheduling
- Tools/products/workflows: Retraining with new semantics; class-agnostic edge/vertex discovery; domain-adaptive scene encoding
- Assumptions/dependencies: Annotated datasets for new domains; revised semantic taxonomies; handling of curved and non-planar elements
- Indoor structured wireframes for AR navigation and facilities management
- Sectors: AR/VR, Facilities, Retail
- Use cases: Ceiling-grid and wall-corner wireframes for AR overlays, asset placement, and wayfinding without dense scans
- Tools/products/workflows: Indoor-specific semantics; integration with SLAM; mesh or plane reconstruction from wireframe graphs
- Assumptions/dependencies: New training data and classes; robust depth indoors; occlusion-heavy environments
- Automated code-compliance and permitting checks
- Sectors: Public policy, AEC
- Use cases: Verifying roof pitch, setback from eaves, skylight placements, and solar-readiness against local codes
- Tools/products/workflows: Rule engines operating on wireframe topology; audit trails with HSS-like quality scores
- Assumptions/dependencies: Regulatory acceptance; quantified accuracy thresholds and uncertainty reporting; appeal/review workflows
- Disaster response at scale with uncertainty-aware triage
- Sectors: Emergency management, NGOs
- Use cases: Prioritizing assets based on structural changes in wireframes pre/post-event; confidence-weighted deployment plans
- Tools/products/workflows: Ensemble-based uncertainty maps; dashboards combining topology change and probability of damage
- Assumptions/dependencies: Consistent pre-event baselines; robust alignment under viewpoint drift; handling debris occlusions
- Marketplace and analytics for privacy-safe property geometry
- Sectors: Real estate, Finance/Underwriting, PropTech
- Use cases: Risk scoring (wind/hail), valuation features (roof complexity), renovation cost estimators
- Tools/products/workflows: API delivering simplified geometric features; subscription dashboards; connectors to underwriting models
- Assumptions/dependencies: Market acceptance of derived data; calibration across geographies; clear provenance and consent mechanisms
- Cross-modal training and weak supervision to reduce manual labels
- Sectors: Academia, AI/ML tooling
- Use cases: Leveraging synthetic data, LiDAR, or self-supervised pretraining to reduce dependence on per-view roof-specific segmentations
- Tools/products/workflows: Self-training with pseudo-labels; contrastive pretraining for scene tokens; curriculum from simple to complex topologies
- Assumptions/dependencies: Access to simulators or synthetic assets; effective domain adaptation to real scenes; stability of flow-matching under weaker supervision
- Standards and metrics for structured 3D quality in procurement
- Sectors: Government, Industry consortia
- Use cases: Adopting metrics like HSS for vendor evaluation and contract SLAs on topology and metric accuracy
- Tools/products/workflows: Open benchmarking suites; certification procedures; reporting templates
- Assumptions/dependencies: Consensus on task definitions; governance for public datasets; periodic metric updates for new structure types
Notes on feasibility and dependencies common across applications:
- Inputs: Method assumes availability of SfM, metric depth (or scale-fit), and per-view semantic segmentations; in many pipelines, these require additional models and quality controls.
- Domain shift: Trained on residential roofs (HoHo dataset). Deployment to other geographies/architectures or to non-roof structures requires fine-tuning and new semantics.
- Accuracy vs. latency: Multi-sample consensus improves stability but increases runtime; production systems may use fewer samples and report uncertainty.
- Privacy: Although RGB is not required for inference, segmentation and depth typically originate from images; policies should dictate immediate discarding of RGB if privacy is a goal.
- Compute: The reported large model (34M params) is moderate for GPUs; edge deployment needs compression/distillation.
Glossary
- ADE20k: A large-scale scene parsing dataset commonly used for semantic segmentation. "ADE20k classes"
- AdamW: An optimizer variant of Adam with decoupled weight decay for better generalization. "fused AdamW (weight decay )"
- all-reduce: A distributed operation that aggregates tensors across devices (e.g., summing gradients). "bf16-compressed gradient all-reduce"
- autocast: Automatic mixed-precision casting that selects lower-precision dtypes during computation to speed up training. "bf16 autocast"
- back-project: To map image pixels with depth back into 3D coordinates using camera geometry. "back-project into additional 3D points"
- BCE (Binary Cross-Entropy): A binary classification loss measuring the difference between predicted probabilities and labels. "pairwise BCE edge loss"
- bf16: bfloat16, a 16-bit floating-point format that preserves large dynamic range while reducing memory/compute. "bf16, DDP"
- camera intrinsics: Parameters describing a camera’s internal calibration (e.g., focal length, principal point). "camera poses and intrinsics"
- COLMAP: A popular Structure-from-Motion system producing sparse 3D reconstructions and camera poses. "COLMAP point cloud"
- convex hull: The smallest convex set enclosing a collection of points. "convex hull of the predicted vertices"
- cosine decay: A learning-rate schedule that decays following a cosine curve. "cosine decay"
- cross-attend: An attention mechanism where one set of tokens attends to another set for conditioning. "cross-attends to the full point set"
- DDP (Distributed Data Parallel): A parallel training approach (e.g., in PyTorch) that synchronizes gradients across GPUs. "with DDP"
- DiT (Diffusion Transformer): A diffusion-model architecture built with transformer blocks. "a DiT-style transformer"
- Euler steps: Discrete steps of the explicit Euler method for integrating ODEs. "integrated with 50 Euler steps"
- Euler update: A single explicit Euler integration update step for an ODE. "used by the Euler update"
- F1 score: The harmonic mean of precision and recall, used for classification performance. "The vertex term is the F1"
- flow matching: A training framework that learns a velocity field to transport samples from noise to data. "flow matching"
- flow-matching ODE: An ODE whose vector field is trained via flow matching to generate data from noise. "flow-matching ODE"
- Fourier encoding: Mapping coordinates to sinusoidal features to capture high-frequency variations. "a Fourier encoding of that position"
- FPS (Farthest Point Sampling): A point selection method that iteratively picks the farthest point to cover space uniformly. "priority-aware Gestalt FPS"
- Gestalt (roof-specific classes): A custom semantic label set for roof elements used in this dataset. "roof-specific Gestalt classes"
- gradient clipping: Technique that caps gradient norms to stabilize and prevent exploding gradients. "gradient clipping at 1.0"
- HSS (Hybrid Structure Score): A metric combining vertex and edge accuracy to evaluate 3D wireframes. "Hybrid Structure Score is thus"
- Hungarian assignment: An algorithm for optimal bipartite matching used to align predictions and ground truth. "under an optimal (Hungarian) assignment"
- IoU (Intersection over Union): An overlap metric measuring intersection area over union area; here extended volumetrically. "volumetric IoU"
- LayerNorm: Layer Normalization, normalizing features within a layer to stabilize training. "adaptive LayerNorm modulation"
- linear warmup: A schedule that increases the learning rate linearly at the start of training. "1000-step linear warmup"
- medoid: The representative sample in a set minimizing total distance to all others. "We select the medoid prediction"
- monocular metric depth: Depth predicted from single images with an absolute metric scale. "monocular metric depth drifts in scale"
- ODE (Ordinary Differential Equation): A continuous-time equation governing dynamics, often integrated numerically. "learned ODE"
- Perceiver: A transformer architecture using latent arrays and cross-attention to handle diverse inputs. "Perceiver-style scene encoder"
- permutation-invariant: Insensitive to the ordering of elements in a set. "permutation-invariant"
- scale-fit (scale-fitted depth): Aligning predicted depth scales to a reference for metric consistency. "scale-fit against the COLMAP points"
- sinusoidal time embedding: Encoding time with sinusoids to provide temporal conditioning to a model. "a sinusoidal time embedding is used"
- SmoothL1: A robust regression loss combining L1 and L2 regions (Huber-like). "SmoothL1 velocity loss"
- stochastic sampler: A sampling process involving randomness (e.g., random initializations or noise). "keeps the stochastic sampler well behaved."
- Structure-from-Motion (SfM): Recovering 3D structure and camera poses from multiple images. "Structure-from-Motion (SfM)"
- vertex slots: A fixed set of learnable tokens representing candidate vertex positions. "the denoiser refines the stage-1 vertex slots"
- weight decay: L2-like regularization added to weights to reduce overfitting. "weight decay "
Collections
Sign up for free to add this paper to one or more collections.