fj-core 0.49.0

Early-stage b-rep CAD kernel.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use fj_math::Vector;

use crate::{
    objects::{Face, Region, Shell},
    operations::{
        derive::DeriveFrom,
        insert::Insert,
        presentation::GetColor,
        reverse::Reverse,
        sweep::{SweepCache, SweepRegion},
        update::UpdateShell,
    },
    storage::Handle,
    Core,
};

/// # Sweep a [`Face`] that is part of a [`Shell`]
///
/// See [module documentation] for more information.
///
/// [module documentation]: super
pub trait SweepFaceOfShell {
    /// # Sweep the [`Face`] of the [`Shell`]
    ///
    /// Extends the shell, adding the new faces to it.
    ///
    /// # Limitation
    ///
    ///  When generating new faces, these must NOT coincide with any existing faces in the shell.
    ///
    /// # Panics
    ///
    /// Panics, if the face has interior cycles. This is not a fundamental
    /// limitation, but none the less not yet supported.
    fn sweep_face_of_shell(
        &self,
        face: Handle<Face>,
        path: impl Into<Vector<3>>,
        core: &mut Core,
    ) -> ShellExtendedBySweep;
}

impl SweepFaceOfShell for Shell {
    fn sweep_face_of_shell(
        &self,
        face: Handle<Face>,
        path: impl Into<Vector<3>>,
        core: &mut Core,
    ) -> ShellExtendedBySweep {
        let path = path.into();

        if !face.region().interiors().is_empty() {
            todo!(
                "Sweeping shell faces with interior cycles is not yet \
                supported."
            )
        }

        let mut cache = SweepCache::default();

        let exterior = face
            .region()
            .exterior()
            .reverse(core)
            .insert(core)
            .derive_from(face.region().exterior(), core);
        let region = Region::new(exterior, []);
        let swept_region = region.sweep_region(
            face.surface(),
            face.region().get_color(core),
            path,
            &mut cache,
            core,
        );

        let shell = self
            .remove_face(&face)
            .add_faces(swept_region.clone().all_faces(), core);

        ShellExtendedBySweep {
            shell,
            side_faces: swept_region.side_faces,
            top_face: swept_region.top_face,
        }
    }
}

/// The result of sweeping a [`Face`] of a [`Shell`]
///
/// See [`SweepFaceOfShell`].
pub struct ShellExtendedBySweep {
    /// The resulting shell after the sweep
    pub shell: Shell,

    /// The side faces created by the sweep
    pub side_faces: Vec<Face>,

    /// The top face created by the sweep
    pub top_face: Face,
}