Struct ReconBuilder 

pub struct ReconBuilder { /* private fields */ }

Plan recorder. Methods only record and do not run anything. Validate with ReconBuilder::build.

Implementations

impl ReconBuilder

pub fn plan(&self) -> &Plan

The plan recorded so far.

pub fn input(self, src: impl AsRef<Path>) -> Self

Input folder: images <src>/images/<camera>/, GPS <src>/gps_ref.txt.

pub fn images(self, dir: impl Into<PathBuf>) -> Self

Only specify the image folder (parent of the camera folders).

pub fn cameras<S: Into<String>>(self, cams: impl IntoIterator<Item = S>) -> Self

List of camera folders (frame-bundle order).

pub fn preset(self, name: &str) -> Self

Apply a preset (cameras, pairing strategy, stride). An unknown name is an error in build. aerial-formation: camF/camR/camL, formation pairing rule, stride 3.

pub fn stride(self, n: usize) -> Self

File number interval.

pub fn positions(self, n: usize) -> Self

Only the first N positions.

pub fn pairing(self, p: Pairing) -> Self

Pairing strategy.

pub fn zones(self, span: usize, overlap: usize) -> Self

Zone size and overlap (number of positions).

pub fn gps(self, path: impl Into<PathBuf>) -> Self

GPS record file.

pub fn no_gps(self) -> Self

No GPS file (to turn off alignment too, pass AlignFrame::None to ReconBuilder::align).

pub fn align(self, frame: AlignFrame) -> Self

Alignment coordinate frame.

pub fn fixed_enu_origin(self, on: bool) -> Self

Fix the session ENU origin to the first GPS line.

pub fn features(self, f: Features) -> Self

Feature extraction settings.

pub fn match_backend(self, name: &str) -> Self

Matching backend (cpu|cuda).

pub fn gpu(self) -> Self

Set the SIFT, matching, sparse-stage, PatchMatch, undistortion and bundle adjustment backends all to cuda.

pub fn incremental_triangulation(self, on: bool) -> Self

Triangulate only newly registered images.

pub fn stable_display(self, on: bool) -> Self

Stable display (see SessionConfig::stable_display).

pub fn settle(self, tol: f64, max_zone: usize) -> Self

Stable display settling: intrinsics change tolerance and the last zone that may still settle (see SessionConfig::settle_tol, SessionConfig::settle_max_zone).

pub fn lookahead(self, positions: usize) -> Self

Positions whose features are extracted ahead of the position loop (see SessionConfig::lookahead; 0 = off, the default).

pub fn preview(self, on: bool) -> Self

Stable display: sparse preview of every zone when it closes (see SessionConfig::preview).

pub fn dense(self, d: Dense) -> Self

Densification plan (on).

pub fn no_dense(self) -> Self

Densification off.

pub fn sinks(self, s: Sinks) -> Self

Output hook plan.

pub fn seed(self, seed: u64) -> Self

RANSAC seed.

pub fn threads(self, n: usize) -> Self

Number of rayon threads (0 = number of cores).

pub fn on<F>(self, kind: EventKind, f: F) -> Self

where F: FnMut(&Event) + Send + 'static,

A hook for a specific kind (Pipeline::on). Choosing EventKind::FrameDecoded turns frame decoding on.

pub fn on_frame<F>(self, f: F) -> Self

where F: FnMut(&Arc<Frame>) + Send + 'static,

Frame hook (Pipeline::on_frame): receives each decoded input frame (RGB), one camera at a time, before the position is processed. Registering one turns frame decoding on.

Examples found in repository

examples/frame_hook_plan.rs (lines 61-73)

fn main() -> Result<(), String> {
    let path = std::env::args().nth(1).ok_or("usage: frame_hook_plan <plan.toml>")?;
    let plan = Plan::load(&path)?;
    let seen = Arc::new(Mutex::new(Seen::default()));
    let refined = Arc::new(Mutex::new(Vec::new()));
    let t0 = Instant::now();
    let (s, r) = (seen.clone(), refined.clone());
    let recon = Recon::from_plan(plan)
        .on_frame(move |f: &Arc<Frame>| {
            let mut s = s.lock().unwrap();
            let t = t0.elapsed().as_secs_f64();
            s.first_s.get_or_insert(t);
            s.last_s = t;
            *s.per_camera.entry(f.camera.clone()).or_default() += 1;
            *s.sizes.entry((f.width, f.height)).or_default() += 1;
            s.bytes += f.rgb.len();
            s.positions = s.positions.max(f.position + 1);
            if f.rgb.len() != (f.width * f.height * 3) as usize || f.width == 0 {
                s.bad += 1;
            }
        })
        .on_zone_refined(move |z, cloud| r.lock().unwrap().push((z.zone, cloud.len())))
        .build()
        .map_err(|e| e.to_string())?;
    let summary = recon.run()?;
    let s = seen.lock().unwrap();
    let total: usize = s.per_camera.values().sum();
    println!(
        "frame hook: {total} frames over {} positions, per camera {:?}, sizes {:?}, {:.1} MB RGB, bad {}",
        s.positions,
        s.per_camera,
        s.sizes,
        s.bytes as f64 / 1e6,
        s.bad
    );
    println!(
        "frame hook: first frame at {:.2}s, last at {:.2}s; run total {:.1}s",
        s.first_s.unwrap_or(0.0),
        s.last_s,
        t0.elapsed().as_secs_f64()
    );
    println!("refined zones (zone, dense points): {:?}", refined.lock().unwrap());
    println!("events {}, hook calls {}, hook panics {}", summary.events, summary.hook_calls, summary.hook_panics);
    if total == 0 || s.bad > 0 || summary.hook_panics > 0 {
        return Err("frame hook check failed".into());
    }
    Ok(())
}

pub fn on_any<F>(self, f: F) -> Self

where F: FnMut(&Event) + Send + 'static,

Hook for all events (Pipeline::on_any).

pub fn on_zone_preview<F>(self, f: F) -> Self

where F: FnMut(ZoneRange, &Arc<PointCloud>) + Send + 'static,

Zone preview point-cloud hook (Pipeline::on_zone_preview).

pub fn on_zone_refined<F>(self, f: F) -> Self

where F: FnMut(ZoneRange, &Arc<PointCloud>) + Send + 'static,

Zone refined point-cloud hook (Pipeline::on_zone_refined).

Examples found in repository

examples/frame_hook_plan.rs (line 74)

fn main() -> Result<(), String> {
    let path = std::env::args().nth(1).ok_or("usage: frame_hook_plan <plan.toml>")?;
    let plan = Plan::load(&path)?;
    let seen = Arc::new(Mutex::new(Seen::default()));
    let refined = Arc::new(Mutex::new(Vec::new()));
    let t0 = Instant::now();
    let (s, r) = (seen.clone(), refined.clone());
    let recon = Recon::from_plan(plan)
        .on_frame(move |f: &Arc<Frame>| {
            let mut s = s.lock().unwrap();
            let t = t0.elapsed().as_secs_f64();
            s.first_s.get_or_insert(t);
            s.last_s = t;
            *s.per_camera.entry(f.camera.clone()).or_default() += 1;
            *s.sizes.entry((f.width, f.height)).or_default() += 1;
            s.bytes += f.rgb.len();
            s.positions = s.positions.max(f.position + 1);
            if f.rgb.len() != (f.width * f.height * 3) as usize || f.width == 0 {
                s.bad += 1;
            }
        })
        .on_zone_refined(move |z, cloud| r.lock().unwrap().push((z.zone, cloud.len())))
        .build()
        .map_err(|e| e.to_string())?;
    let summary = recon.run()?;
    let s = seen.lock().unwrap();
    let total: usize = s.per_camera.values().sum();
    println!(
        "frame hook: {total} frames over {} positions, per camera {:?}, sizes {:?}, {:.1} MB RGB, bad {}",
        s.positions,
        s.per_camera,
        s.sizes,
        s.bytes as f64 / 1e6,
        s.bad
    );
    println!(
        "frame hook: first frame at {:.2}s, last at {:.2}s; run total {:.1}s",
        s.first_s.unwrap_or(0.0),
        s.last_s,
        t0.elapsed().as_secs_f64()
    );
    println!("refined zones (zone, dense points): {:?}", refined.lock().unwrap());
    println!("events {}, hook calls {}, hook panics {}", summary.events, summary.hook_calls, summary.hook_panics);
    if total == 0 || s.bad > 0 || summary.hook_panics > 0 {
        return Err("frame hook check failed".into());
    }
    Ok(())
}

pub fn on_snapshot<F>(self, f: F) -> Self

where F: FnMut(usize, &Arc<PointCloud>) + Send + 'static,

Snapshot hook (Pipeline::on_snapshot).

pub fn on_position_done<F>(self, f: F) -> Self

where F: FnMut(usize, usize, usize) + Send + 'static,

Position-done hook (Pipeline::on_position_done).

pub fn on_message<F>(self, f: F) -> Self

where F: FnMut(EventKind, &str) + Send + 'static,

Warning/error message hook (Pipeline::on_message).

pub fn policy(self, kind: EventKind, p: QueuePolicy) -> Self

Per-kind queue policy (Pipeline::policy).

pub fn build(self) -> Result<Recon, PlanError>

Validate the plan -> an executable Recon. It neither creates nor deletes files or folders (it only reads the input folder listing and the GPS file).

Checks: input and camera folders exist, number of selected positions, alignment and GPS file, backend names and device (when CUDA is requested), output folder writable, option value ranges. All problems are collected and returned at once as a PlanError.

Examples found in repository

examples/frame_hook_plan.rs (line 75)

fn main() -> Result<(), String> {
    let path = std::env::args().nth(1).ok_or("usage: frame_hook_plan <plan.toml>")?;
    let plan = Plan::load(&path)?;
    let seen = Arc::new(Mutex::new(Seen::default()));
    let refined = Arc::new(Mutex::new(Vec::new()));
    let t0 = Instant::now();
    let (s, r) = (seen.clone(), refined.clone());
    let recon = Recon::from_plan(plan)
        .on_frame(move |f: &Arc<Frame>| {
            let mut s = s.lock().unwrap();
            let t = t0.elapsed().as_secs_f64();
            s.first_s.get_or_insert(t);
            s.last_s = t;
            *s.per_camera.entry(f.camera.clone()).or_default() += 1;
            *s.sizes.entry((f.width, f.height)).or_default() += 1;
            s.bytes += f.rgb.len();
            s.positions = s.positions.max(f.position + 1);
            if f.rgb.len() != (f.width * f.height * 3) as usize || f.width == 0 {
                s.bad += 1;
            }
        })
        .on_zone_refined(move |z, cloud| r.lock().unwrap().push((z.zone, cloud.len())))
        .build()
        .map_err(|e| e.to_string())?;
    let summary = recon.run()?;
    let s = seen.lock().unwrap();
    let total: usize = s.per_camera.values().sum();
    println!(
        "frame hook: {total} frames over {} positions, per camera {:?}, sizes {:?}, {:.1} MB RGB, bad {}",
        s.positions,
        s.per_camera,
        s.sizes,
        s.bytes as f64 / 1e6,
        s.bad
    );
    println!(
        "frame hook: first frame at {:.2}s, last at {:.2}s; run total {:.1}s",
        s.first_s.unwrap_or(0.0),
        s.last_s,
        t0.elapsed().as_secs_f64()
    );
    println!("refined zones (zone, dense points): {:?}", refined.lock().unwrap());
    println!("events {}, hook calls {}, hook panics {}", summary.events, summary.hook_calls, summary.hook_panics);
    if total == 0 || s.bad > 0 || summary.hook_panics > 0 {
        return Err("frame hook check failed".into());
    }
    Ok(())
}

Trait Implementations

impl Debug for ReconBuilder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.