ifc-lite-processing 15.1.0

Shared IFC processing pipeline and types used by server and FFI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
//! One registered capture behind the shared atlas sampler: a textured mesh
//! answers with UVs into its image, an RGB point cloud answers with a colour.
use super::{
    transfer_budget::TransferBudget,
    transfer_math::Point,
    transfer_occlusion::Occluder,
    transfer_points::PointSurface,
    transfer_surface::{Observation, Surface},
    transfer_target::TargetTriangle,
    transfer_types::*,
};

pub(super) enum Sample {
    Uv([f64; 2]),
    Rgba([f64; 4]),
}
pub(super) enum ScanSource {
    Mesh(Surface),
    Points(Box<PointSurface>, Option<Occluder>),
}
impl ScanSource {
    pub fn new(
        request: &MeshTransferRequest,
        payload: Option<&TransferPointPayload<'_>>,
        frame: &TransferFrame,
        budget: &mut TransferBudget,
    ) -> Result<Self, String> {
        match (&request.source, payload) {
            (TransferSource::Mesh(_), None) => Ok(Self::Mesh(Surface::new(request, frame, budget)?)),
            (TransferSource::Points(spec), Some(points)) => {
                Ok(Self::Points(Box::new(PointSurface::new(request, spec, points, frame, budget)?), None))
            }
            (TransferSource::Mesh(_), Some(_)) => Err("Transfer mesh source must not carry a point payload".into()),
            (TransferSource::Points(_), None) => Err("Transfer point source needs its binary point payload".into()),
        }
    }
    pub fn summary(request: &MeshTransferRequest) -> TransferSourceSummary {
        match &request.source {
            TransferSource::Mesh(_) => TransferSourceSummary { kind: "mesh".into(), orientation: None, point_count: None },
            TransferSource::Points(spec) => TransferSourceSummary {
                kind: "points".into(),
                orientation: Some(spec.orientation),
                point_count: Some(spec.point_count),
            },
        }
    }
    /// Point sources refuse captures beyond the current item's other faces.
    pub fn begin_item(&mut self, targets: &[TargetTriangle], budget: &mut TransferBudget) -> Result<(), String> {
        if let Self::Points(_, occluder) = self {
            *occluder = Some(Occluder::new(targets, budget)?);
        }
        Ok(())
    }
    pub fn observe(
        &mut self,
        point: Point,
        target_normal: Point,
        budget: &mut TransferBudget,
    ) -> Result<(Observation, Sample), String> {
        match self {
            Self::Mesh(surface) => {
                let (observation, uv) = surface.observe(point, target_normal, budget)?;
                Ok((observation, Sample::Uv(uv)))
            }
            Self::Points(surface, occluder) => {
                let occluder = occluder.as_mut().ok_or("Transfer point observation outside an item")?;
                let (observation, rgba) = surface.observe(point, target_normal, occluder, budget)?;
                Ok((observation, Sample::Rgba(rgba)))
            }
        }
    }
}