Struct SessionConfig 

pub struct SessionConfig {

    pub image_root: PathBuf,
    pub gps: Vec<GpsRecord>,
    pub span: usize,
    pub overlap: usize,
    pub total_positions: Option<usize>,
    pub incremental_triangulation: bool,
    pub fixed_enu_origin: bool,
    pub seed: Option<u64>,
    pub extraction: ExtractionOptions,
    pub sift: Arc<dyn SiftEngine>,
    pub matcher: Arc<dyn MatcherBackend>,
    pub ba_backend: Arc<dyn BaBackend>,
    pub sparse: SparseBackends,
    pub dense: Option<DenseConfig>,
    pub history: usize,
    pub decode_frames: bool,
    pub stable_display: bool,
    pub gps_prior_sigma: f64,
    pub settle_tol: f64,
    pub settle_max_zone: usize,
    pub intrinsics_prior: Option<Arc<IntrinsicsPrior>>,
    pub lookahead: usize,
    pub preview: bool,
}

Session settings.

Fields

image_root: PathBuf

Input image folder (base of the image names).

gps: Vec<GpsRecord>

GPS records (alignment order = this order).

span: usize

Zone size and overlap (in units of positions).

overlap: usize

Zone overlap (number of positions).

total_positions: Option<usize>

Total number of known positions. If set, the last zones are closed at the last position; if not, they are closed in finish.

incremental_triangulation: bool

Triangulate only newly registered images.

fixed_enu_origin: bool

Fix the ENU origin to the first GPS record (default: the first common record at each alignment).

seed: Option<u64>

RANSAC seed for two-view geometry and GPS alignment.

extraction: ExtractionOptions

Feature extraction options.

sift: Arc<dyn SiftEngine>

SIFT backend.

matcher: Arc<dyn MatcherBackend>

Descriptor matching backend.

ba_backend: Arc<dyn BaBackend>

Bundle adjustment backend (zone refinement BA, BA of the first model’s global mapper).

sparse: SparseBackends

Sparse-stage backends (geometric verification, registration, triangulation).

dense: Option<DenseConfig>

Densification settings (None = skip densification, point-cloud events carry dense: false).

history: usize

Number of per-position rewind points kept for Command::ResetFrom (0 = no rewind, saves memory).

decode_frames: bool

Decode input frames to RGB and emit them as Event::FrameDecoded before processing (off by default).

stable_display: bool

Stable display (default off). No preview densification; the refinement of zone K waits for zone K−1, takes the cameras already shown by it (pose and intrinsics, copied exactly) as fixed in its bundle adjustment, and is not re-aligned to GPS, so a zone never moves after it is shown and the space only grows. The coordinate frame is the first refined zone’s (local). AllRefinedDone::chain is the final model aligned to GPS (ENU) once.

gps_prior_sigma: f64

Stable display: standard deviation (m) of the GPS position prior on each newly placed camera. ≤ 0 disables the prior (then the shown frame is local and drifts with the chain).

settle_tol: f64

Stable display: until settled, every refined zone re-adjusts all earlier cameras and the intrinsics (shown zones are re-placed). Once the largest relative focal change between two consecutive refined models is below this (default 0.01 = 1 %), the display settles: from then on shown cameras and intrinsics are frozen.

settle_max_zone: usize

Stable display: the display settles by force at this zone at the latest (default 3).

intrinsics_prior: Option<Arc<IntrinsicsPrior>>

Soft intrinsics prior (see crate::intrinsics): every camera starts from the prior values as soon as it exists and each refinement pulls its refined parameters back towards them. None = off.

lookahead: usize

Positions whose features may be extracted ahead of the position loop (default 0 = off). A Lookahead handle (Session::lookahead) gets the frame sets of upcoming positions; one worker thread extracts at most this many of them into the feature store while the earlier positions are matched, registered and triangulated. The results are the same as without lookahead.

preview: bool

Stable display: show a sparse preview of every zone as soon as it closes (default off). The zone’s registered points (no bundle adjustment yet) are placed into the display frame (robust Sim3 on the 3D points shared with the latest shown zone; before any zone is shown, the GPS ENU fit the first refined zone uses) and emitted as an Event::ZonePreview with dense: false and frame: "display". The refined zone later replaces it. Shown zones are never touched.

Implementations

impl SessionConfig

pub fn new(image_root: impl Into<PathBuf>) -> Self

Defaults: zone 12 / overlap 2, SIFT up to 8192 features and input 3200, CPU SIFT and matching, no densification, rewind 8.

Examples found in repository

examples/hooks.rs (line 61)

fn main() -> Result<(), String> {
    let out = std::env::args().nth(1).map(PathBuf::from).unwrap_or_else(|| std::env::temp_dir().join("cumulus3d_hooks"));
    let src = out.with_extension("src");
    if !src.join("gps_ref.txt").exists() {
        common::make_dataset(&src);
    }
    if out.exists() {
        std::fs::remove_dir_all(&out).map_err(|e| e.to_string())?;
    }
    let layout = Layout::discover(&src, 1)?;
    let npos = layout.frames.len();

    let mut cfg = SessionConfig::new(src.join("images"));
    cfg.gps = read_gps_file(src.join("gps_ref.txt")).map_err(|e| e.to_string())?;
    (cfg.span, cfg.overlap, cfg.total_positions, cfg.seed) = (4, 1, Some(npos), Some(7));
    if cumulus3d_cuda::is_available() {
        let mut d = DenseConfig::new(make_pm_backend("cuda"), parse_profile("fast")?);
        d.undistort.max_image_size = 160;
        cfg.dense = Some(d);
    }

    // Hook: print event text, zone point-cloud point counts, warnings and errors; plus the default output hook (files).
    let pipeline = Pipeline::new(Session::new(cfg))
        .on_any(|e: &Event| {
            if let Some(t) = e.timeline_text() {
                println!("[event v{}] {t}", e.meta().version);
            }
        })
        .on(EventKind::ZonePreview, |e: &Event| {
            if let Event::ZonePreview { range, cloud, model, .. } = e {
                println!("  초벌 {}: 조밀 점 {} / 희소 점 {}", range.zone, cloud.len(), model.num_points3d());
            }
        })
        .on(EventKind::ZoneRefined, |e: &Event| {
            if let Event::ZoneRefined { range, cloud, model, .. } = e {
                println!("  정밀 {}: 조밀 점 {} / 희소 점 {}", range.zone, cloud.len(), model.num_points3d());
            }
        })
        .on_message(|k, m| eprintln!("  {k:?}: {m}"));
    let mut pipeline = sinks::attach(pipeline, &out, &SinkOptions::default()).map_err(|e| e.to_string())?;

    for p in 0..npos {
        pipeline.push(Input::Frames(FrameSet::new(CAMS.iter().map(|c| (*c, layout.name(c, p))))));
    }
    let (_, summary) = pipeline.finish();
    println!("이벤트 {} 개, 훅 호출 {} 번, 훅 패닉 {}", summary.events, summary.hook_calls, summary.hook_panics);

    for f in ["timeline.txt", "run.log", "snapshots/manifest.json", "snapshots/timeline.txt", "DONE"] {
        let p = out.join(f);
        println!("{} {}", if p.exists() { "있음" } else { "없음" }, p.display());
    }
    Ok(())
}

Trait Implementations

impl Clone for SessionConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.