Struct Plan 

pub struct Plan {

    pub seed: Option<u64>,
    pub threads: usize,
    pub gps: Option<PathBuf>,
    pub pairing: Pairing,
    pub input: Source,
    pub zones: Zones,
    pub align: Align,
    pub features: Features,
    pub matching: Matching,
    pub sparse: Sparse,
    pub live: Live,
    pub dense: Dense,
    pub sinks: Sinks,
}

Reconstruction plan (a value). It runs nothing and only holds “what to do and how”.

The default (Plan::default) is the aerial-formation preset + the cumulus3d stream defaults, and the paths are placeholders (data/images, data/gps_ref.txt, out).

Fields

seed: Option<u64>

RANSAC seed for two-view geometry and GPS alignment (if unset, differs from run to run).

threads: usize

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

gps: Option<PathBuf>

GPS record file (name latitude longitude altitude lines). Without it, alignment is impossible.

pairing: Pairing

Pairing strategy.

input: Source

Input images.

zones: Zones

Zone splitting.

align: Align

Coordinate alignment.

features: Features

Feature extraction.

matching: Matching

Descriptor matching.

sparse: Sparse

Sparse reconstruction.

live: Live

Live throughput: feature extraction ahead, backlog batching, sparse previews.

dense: Dense

Densification.

sinks: Sinks

Output hooks.

Implementations

impl Plan

pub fn to_toml(&self) -> String

As a TOML string.

pub fn to_toml_annotated(&self) -> String

TOML with the profile’s effective dense defaults written as comments under empty [dense.fusion] / [dense.filter] tables (what cumulus3d plan --print-default prints). Comments do not change the plan: from_toml of the result equals self.

pub fn from_toml(s: &str) -> Result<Self, String>

From a TOML string (missing items take defaults, unknown items are an error).

pub fn load(path: impl AsRef<Path>) -> Result<Self, String>

From a TOML file.

Examples found in repository

examples/frame_hook_plan.rs (line 55)

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 from_stream(c: &StreamConfig) -> Self

The plan equivalent to the cumulus3d stream settings (<src>/images, <src>/gps_ref.txt, aerial-formation cameras).

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.

impl Default for Plan

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Plan

where Plan: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Plan

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Plan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Plan