Do multiple chamfer/fillet in one API call

adamchalmers · adamchalmers · commit 3b627995db18 · 2025-05-07T16:27:16.000-05:00
Also add a tolerance param for chamfer calls.
diff --git a/docs/kcl-std/functions/std-solid-chamfer.md b/docs/kcl-std/functions/std-solid-chamfer.md
@@ -12,6 +12,7 @@ chamfer(
   @solid: Solid,
   length: number(Length),
   tags: [Edge; 1+],
+  tolerance?: number(Length),
   tag?: tag,
 ): Solid
 ```
@@ -27,6 +28,7 @@ a sharp, straight transitional edge.
 | `solid` | [`Solid`](/docs/kcl-std/types/std-types-Solid) | The solid whose edges should be chamfered | Yes |
 | `length` | `number(Length)` | The length of the chamfer | Yes |
 | `tags` | [`[Edge; 1+]`](/docs/kcl-std/types/std-types-Edge) | The paths you want to chamfer | Yes |
+| `tolerance` | `number(Length)` | The tolerance for this fillet | No |
 | [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Create a new tag which refers to this chamfer | No |
 
 ### Returns
diff --git a/rust/kcl-lib/src/std/chamfer.rs b/rust/kcl-lib/src/std/chamfer.rs
@@ -21,19 +21,21 @@ pub(crate) const DEFAULT_TOLERANCE: f64 = 0.0000001;
 pub async fn chamfer(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
     let solid = args.get_unlabeled_kw_arg_typed("solid", &RuntimeType::Primitive(PrimitiveType::Solid), exec_state)?;
     let length: TyF64 = args.get_kw_arg_typed("length", &RuntimeType::length(), exec_state)?;
+    let tolerance: Option<TyF64> = args.get_kw_arg_opt_typed("tolerance", &RuntimeType::length(), exec_state)?;
     let tags = args.kw_arg_array_and_source::<EdgeReference>("tags")?;
     let tag = args.get_kw_arg_opt("tag")?;
 
     super::fillet::validate_unique(&tags)?;
     let tags: Vec<EdgeReference> = tags.into_iter().map(|item| item.0).collect();
-    let value = inner_chamfer(solid, length, tags, tag, exec_state, args).await?;
+    let value = inner_chamfer(solid, length, tags, tolerance, tag, exec_state, args).await?;
     Ok(KclValue::Solid { value })
 }
 
 async fn inner_chamfer(
     solid: Box<Solid>,
     length: TyF64,
     tags: Vec<EdgeReference>,
+    tolerance: Option<TyF64>,
     tag: Option<TagNode>,
     exec_state: &mut ExecState,
     args: Args,
@@ -46,47 +48,63 @@ async fn inner_chamfer(
             source_ranges: vec![args.source_range],
         }));
     }
+    if tags.is_empty() {
+        return Err(KclError::Semantic(KclErrorDetails {
+            source_ranges: vec![args.source_range],
+            message: "You must chamfer at least one tag".to_owned(),
+        }));
+    }
 
     let mut solid = solid.clone();
-    for edge_tag in tags {
-        let edge_id = match edge_tag {
-            EdgeReference::Uuid(uuid) => uuid,
-            EdgeReference::Tag(edge_tag) => args.get_tag_engine_info(exec_state, &edge_tag)?.id,
-        };
+    let edge_ids: Vec<_> = tags
+        .into_iter()
+        .map(|edge_tag| {
+            let id = match edge_tag {
+                EdgeReference::Uuid(uuid) => uuid,
+                EdgeReference::Tag(edge_tag) => args.get_tag_engine_info(exec_state, &edge_tag)?.id,
+            };
+            Ok::<_, KclError>(id)
+        })
+        .collect::<Result<Vec<_>, _>>()?;
 
-        let id = exec_state.next_uuid();
-        args.batch_end_cmd(
-            id,
-            ModelingCmd::from(mcmd::Solid3dFilletEdge {
-                edge_id: None,
-                edge_ids: vec![edge_id],
-                extra_face_ids: vec![],
-                strategy: Default::default(),
-                object_id: solid.id,
-                radius: LengthUnit(length.to_mm()),
-                tolerance: LengthUnit(DEFAULT_TOLERANCE), // We can let the user set this in the future.
-                cut_type: CutType::Chamfer,
-            }),
-        )
-        .await?;
+    let id = exec_state.next_uuid();
+    let mut extra_face_ids = Vec::new();
+    let num_extra_ids = edge_ids.len() - 1;
+    for _ in 0..num_extra_ids {
+        extra_face_ids.push(exec_state.next_uuid());
+    }
+    args.batch_end_cmd(
+        id,
+        ModelingCmd::from(mcmd::Solid3dFilletEdge {
+            edge_id: None,
+            edge_ids: edge_ids.clone(),
+            extra_face_ids,
+            strategy: Default::default(),
+            object_id: solid.id,
+            radius: LengthUnit(length.to_mm()),
+            tolerance: LengthUnit(tolerance.as_ref().map(|t| t.to_mm()).unwrap_or(DEFAULT_TOLERANCE)),
+            cut_type: CutType::Chamfer,
+        }),
+    )
+    .await?;
 
-        solid.edge_cuts.push(EdgeCut::Chamfer {
-            id,
-            edge_id,
-            length: length.clone(),
-            tag: Box::new(tag.clone()),
-        });
+    let new_edge_cuts = edge_ids.into_iter().map(|edge_id| EdgeCut::Chamfer {
+        id,
+        edge_id,
+        length: length.clone(),
+        tag: Box::new(tag.clone()),
+    });
+    solid.edge_cuts.extend(new_edge_cuts);
 
-        if let Some(ref tag) = tag {
-            solid.value.push(ExtrudeSurface::Chamfer(ChamferSurface {
-                face_id: id,
-                tag: Some(tag.clone()),
-                geo_meta: GeoMeta {
-                    id,
-                    metadata: args.source_range.into(),
-                },
-            }));
-        }
+    if let Some(ref tag) = tag {
+        solid.value.push(ExtrudeSurface::Chamfer(ChamferSurface {
+            face_id: id,
+            tag: Some(tag.clone()),
+            geo_meta: GeoMeta {
+                id,
+                metadata: args.source_range.into(),
+            },
+        }));
     }
 
     Ok(solid)
diff --git a/rust/kcl-lib/src/std/fillet.rs b/rust/kcl-lib/src/std/fillet.rs
@@ -81,43 +81,65 @@ async fn inner_fillet(
     exec_state: &mut ExecState,
     args: Args,
 ) -> Result<Box<Solid>, KclError> {
+    // If you try and tag multiple edges with a tagged fillet, we want to return an
+    // error to the user that they can only tag one edge at a time.
+    if tag.is_some() && tags.len() > 1 {
+        return Err(KclError::Type(KclErrorDetails {
+            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(),
+            source_ranges: vec![args.source_range],
+        }));
+    }
+    if tags.is_empty() {
+        return Err(KclError::Semantic(KclErrorDetails {
+            source_ranges: vec![args.source_range],
+            message: "You must fillet at least one tag".to_owned(),
+        }));
+    }
+
     let mut solid = solid.clone();
-    for edge_tag in tags {
-        let edge_id = edge_tag.get_engine_id(exec_state, &args)?;
+    let edge_ids = tags
+        .into_iter()
+        .map(|edge_tag| edge_tag.get_engine_id(exec_state, &args))
+        .collect::<Result<Vec<_>, _>>()?;
 
-        let id = exec_state.next_uuid();
-        args.batch_end_cmd(
-            id,
-            ModelingCmd::from(mcmd::Solid3dFilletEdge {
-                edge_id: None,
-                edge_ids: vec![edge_id],
-                extra_face_ids: vec![],
-                strategy: Default::default(),
-                object_id: solid.id,
-                radius: LengthUnit(radius.to_mm()),
-                tolerance: LengthUnit(tolerance.as_ref().map(|t| t.to_mm()).unwrap_or(DEFAULT_TOLERANCE)),
-                cut_type: CutType::Fillet,
-            }),
-        )
-        .await?;
+    let id = exec_state.next_uuid();
+    let mut extra_face_ids = Vec::new();
+    let num_extra_ids = edge_ids.len() - 1;
+    for _ in 0..num_extra_ids {
+        extra_face_ids.push(exec_state.next_uuid());
+    }
+    args.batch_end_cmd(
+        id,
+        ModelingCmd::from(mcmd::Solid3dFilletEdge {
+            edge_id: None,
+            edge_ids: edge_ids.clone(),
+            extra_face_ids,
+            strategy: Default::default(),
+            object_id: solid.id,
+            radius: LengthUnit(radius.to_mm()),
+            tolerance: LengthUnit(tolerance.as_ref().map(|t| t.to_mm()).unwrap_or(DEFAULT_TOLERANCE)),
+            cut_type: CutType::Fillet,
+        }),
+    )
+    .await?;
 
-        solid.edge_cuts.push(EdgeCut::Fillet {
-            id,
-            edge_id,
-            radius: radius.clone(),
-            tag: Box::new(tag.clone()),
-        });
+    let new_edge_cuts = edge_ids.into_iter().map(|edge_id| EdgeCut::Fillet {
+        id,
+        edge_id,
+        radius: radius.clone(),
+        tag: Box::new(tag.clone()),
+    });
+    solid.edge_cuts.extend(new_edge_cuts);
 
-        if let Some(ref tag) = tag {
-            solid.value.push(ExtrudeSurface::Fillet(FilletSurface {
-                face_id: id,
-                tag: Some(tag.clone()),
-                geo_meta: GeoMeta {
-                    id,
-                    metadata: args.source_range.into(),
-                },
-            }));
-        }
+    if let Some(ref tag) = tag {
+        solid.value.push(ExtrudeSurface::Fillet(FilletSurface {
+            face_id: id,
+            tag: Some(tag.clone()),
+            geo_meta: GeoMeta {
+                id,
+                metadata: args.source_range.into(),
+            },
+        }));
     }
 
     Ok(solid)
diff --git a/rust/kcl-lib/std/solid.kcl b/rust/kcl-lib/std/solid.kcl
@@ -144,6 +144,8 @@ export fn chamfer(
   length: number(Length),
   /// The paths you want to chamfer
   tags: [Edge; 1+],
+  /// The tolerance for this fillet
+  tolerance?: number(Length),
   /// Create a new tag which refers to this chamfer
   tag?: tag,
 ): Solid {}
