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>>,
}

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.

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.