kcl_lib/std/
fillet.rs

1//! Standard library fillets.
2
3use anyhow::Result;
4use indexmap::IndexMap;
5use kcmc::{ModelingCmd, each_cmd as mcmd, length_unit::LengthUnit, shared::CutType};
6use kittycad_modeling_cmds as kcmc;
7use serde::{Deserialize, Serialize};
8
9use super::{DEFAULT_TOLERANCE_MM, args::TyF64};
10use crate::{
11    SourceRange,
12    errors::{KclError, KclErrorDetails},
13    execution::{
14        EdgeCut, ExecState, ExtrudeSurface, FilletSurface, GeoMeta, KclValue, ModelingCmdMeta, Solid, TagIdentifier,
15        types::RuntimeType,
16    },
17    parsing::ast::types::TagNode,
18    std::Args,
19};
20
21/// A tag or a uuid of an edge.
22#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq, Hash)]
23#[serde(untagged)]
24pub enum EdgeReference {
25    /// A uuid of an edge.
26    Uuid(uuid::Uuid),
27    /// A tag of an edge.
28    Tag(Box<TagIdentifier>),
29}
30
31impl EdgeReference {
32    pub fn get_engine_id(&self, exec_state: &mut ExecState, args: &Args) -> Result<uuid::Uuid, KclError> {
33        match self {
34            EdgeReference::Uuid(uuid) => Ok(*uuid),
35            EdgeReference::Tag(tag) => Ok(args.get_tag_engine_info(exec_state, tag)?.id),
36        }
37    }
38}
39
40pub(super) fn validate_unique<T: Eq + std::hash::Hash>(tags: &[(T, SourceRange)]) -> Result<(), KclError> {
41    // Check if tags contains any duplicate values.
42    let mut tag_counts: IndexMap<&T, Vec<SourceRange>> = Default::default();
43    for tag in tags {
44        tag_counts.entry(&tag.0).or_insert(Vec::new()).push(tag.1);
45    }
46    let mut duplicate_tags_source = Vec::new();
47    for (_tag, count) in tag_counts {
48        if count.len() > 1 {
49            duplicate_tags_source.extend(count)
50        }
51    }
52    if !duplicate_tags_source.is_empty() {
53        return Err(KclError::new_type(KclErrorDetails::new(
54            "The same edge ID is being referenced multiple times, which is not allowed. Please select a different edge"
55                .to_string(),
56            duplicate_tags_source,
57        )));
58    }
59    Ok(())
60}
61
62/// Create fillets on tagged paths.
63pub async fn fillet(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
64    let solid = args.get_unlabeled_kw_arg("solid", &RuntimeType::solid(), exec_state)?;
65    let radius: TyF64 = args.get_kw_arg("radius", &RuntimeType::length(), exec_state)?;
66    let tolerance: Option<TyF64> = args.get_kw_arg_opt("tolerance", &RuntimeType::length(), exec_state)?;
67    let tags = args.kw_arg_edge_array_and_source("tags")?;
68    let tag = args.get_kw_arg_opt("tag", &RuntimeType::tag_decl(), exec_state)?;
69
70    // Run the function.
71    validate_unique(&tags)?;
72    let tags: Vec<EdgeReference> = tags.into_iter().map(|item| item.0).collect();
73    let value = inner_fillet(solid, radius, tags, tolerance, tag, exec_state, args).await?;
74    Ok(KclValue::Solid { value })
75}
76
77async fn inner_fillet(
78    solid: Box<Solid>,
79    radius: TyF64,
80    tags: Vec<EdgeReference>,
81    tolerance: Option<TyF64>,
82    tag: Option<TagNode>,
83    exec_state: &mut ExecState,
84    args: Args,
85) -> Result<Box<Solid>, KclError> {
86    // If you try and tag multiple edges with a tagged fillet, we want to return an
87    // error to the user that they can only tag one edge at a time.
88    if tag.is_some() && tags.len() > 1 {
89        return Err(KclError::new_type(KclErrorDetails {
90            message: "You can only tag one edge at a time with a tagged fillet. Either delete the tag for the fillet fn if you don't need it OR separate into individual fillet functions for each tag.".to_string(),
91            source_ranges: vec![args.source_range],
92            backtrace: Default::default(),
93        }));
94    }
95    if tags.is_empty() {
96        return Err(KclError::new_semantic(KclErrorDetails {
97            source_ranges: vec![args.source_range],
98            message: "You must fillet at least one tag".to_owned(),
99            backtrace: Default::default(),
100        }));
101    }
102
103    let mut solid = solid.clone();
104    let edge_ids = tags
105        .into_iter()
106        .map(|edge_tag| edge_tag.get_engine_id(exec_state, &args))
107        .collect::<Result<Vec<_>, _>>()?;
108
109    let id = exec_state.next_uuid();
110    let mut extra_face_ids = Vec::new();
111    let num_extra_ids = edge_ids.len() - 1;
112    for _ in 0..num_extra_ids {
113        extra_face_ids.push(exec_state.next_uuid());
114    }
115    exec_state
116        .batch_end_cmd(
117            ModelingCmdMeta::from_args_id(exec_state, &args, id),
118            ModelingCmd::from(
119                mcmd::Solid3dFilletEdge::builder()
120                    .edge_ids(edge_ids.clone())
121                    .extra_face_ids(extra_face_ids)
122                    .strategy(Default::default())
123                    .object_id(solid.id)
124                    .radius(LengthUnit(radius.to_mm()))
125                    .tolerance(LengthUnit(
126                        tolerance.as_ref().map(|t| t.to_mm()).unwrap_or(DEFAULT_TOLERANCE_MM),
127                    ))
128                    .cut_type(CutType::Fillet)
129                    .build(),
130            ),
131        )
132        .await?;
133
134    let new_edge_cuts = edge_ids.into_iter().map(|edge_id| EdgeCut::Fillet {
135        id,
136        edge_id,
137        radius: radius.clone(),
138        tag: Box::new(tag.clone()),
139    });
140    solid.edge_cuts.extend(new_edge_cuts);
141
142    if let Some(ref tag) = tag {
143        solid.value.push(ExtrudeSurface::Fillet(FilletSurface {
144            face_id: id,
145            tag: Some(tag.clone()),
146            geo_meta: GeoMeta {
147                id,
148                metadata: args.source_range.into(),
149            },
150        }));
151    }
152
153    Ok(solid)
154}
155
156#[cfg(test)]
157mod tests {
158    use super::*;
159
160    #[test]
161    fn test_validate_unique() {
162        let dup_a = SourceRange::from([1, 3, 0]);
163        let dup_b = SourceRange::from([10, 30, 0]);
164        // Two entries are duplicates (abc) with different source ranges.
165        let tags = vec![("abc", dup_a), ("abc", dup_b), ("def", SourceRange::from([2, 4, 0]))];
166        let actual = validate_unique(&tags);
167        // Both the duplicates should show up as errors, with both of the
168        // source ranges they correspond to.
169        // But the unique source range 'def' should not.
170        let expected = vec![dup_a, dup_b];
171        assert_eq!(actual.err().unwrap().source_ranges(), expected);
172    }
173}
kcl_lib/std/fillet.rs

kcl_lib/std/
fillet.rs
