SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Sheet metal rules: typed input contracts and replies (#6581) (#10921)
PapaEchoccdb470e017d
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rsindex a7d3ba5474..8699e592fe 100644--- a/crates/engine/src/cmd/mod.rs+++ b/crates/engine/src/cmd/mod.rs@@ -97,7 +97,7 @@ mod script_tests;mod sheet;pub(crate) use sheet::{FlangeType, ThenStep, flange_edge, flange_edge_list, flange_position, flange_type, fold_points, fold_position, perforation_pattern, sheet_points,- then_list,+ sheet_rule_name, then_list,};mod silhouette;mod sketch;diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rsindex ce74fff2c3..25168a8112 100644--- a/crates/engine/src/cmd/sheet.rs+++ b/crates/engine/src/cmd/sheet.rs@@ -13,7 +13,10 @@ use super::CommandSpec;use super::features::{add_feature, check_expr, feature_sketch, profiles, sketch_id};use crate::params::{bad, bool_, expr, expr_problem, req_expr, str_, string_list, vec3};use crate::schema::features::FeatureResult;-use crate::schema::sheet::{ConvertParams, FlangeParams, FoldParams, HemParams, PerforateParams, UnfoldParams};+use crate::schema::sheet::{+ ConvertParams, FlangeParams, FoldParams, HemParams, ListedRule, ManageRulesParams, ManageRulesResult, PerforateParams, RuleFeatureError,+ RuleReply, RulesParams, RulesResult, UnfoldParams,+};use crate::schema::{TypedContract, output_schema_for};use crate::{EngineError, Result, Session};@@ -24,6 +27,9 @@ const FOLD_CONTRACT: TypedContract<FoldParams> = TypedContract::new();const UNFOLD_CONTRACT: TypedContract<UnfoldParams> = TypedContract::new();const CONVERT_CONTRACT: TypedContract<ConvertParams> = TypedContract::new();+const RULES_CONTRACT: TypedContract<RulesParams> = TypedContract::new();+const MANAGE_RULES_CONTRACT: TypedContract<ManageRulesParams> = TypedContract::new();+pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("sheet.flange", "Flange", crate::checked!("sheet.flange", flange)).at("SHEET METAL", "CREATE")@@ -101,7 +107,8 @@ pub static COMMANDS: &[CommandSpec] = &[two flat faces tangent to it, either skin), makes it one bend of the rule's radius at their virtual sharp; \the faces' holes become cut-outs and their engravings, up to half the thickness deep, pockets)",),- CommandSpec::new("sheet.manage_rules", "Sheet Metal Rules", rules).at("SHEET METAL", "MODIFY").icon("sheet_rules").params(+ CommandSpec::new("sheet.manage_rules", "Sheet Metal Rules", crate::checked!("sheet.manage_rules", rules))+ .contract(&MANAGE_RULES_CONTRACT).output(output_schema_for::<ManageRulesResult>).at("SHEET METAL", "MODIFY").icon("sheet_rules").params("name (new or existing); thickness?, k_factor?, bend_radius?, relief_width?, relief_depth?, corner_relief?, hem_gap?, gap? (expressions; `Thickness` is the rule's; \gap: between flanges that meet at a corner, whose ends are closed toward each other at any angle); \corner_relief_shape?: notch|round|rectangular|tear (what is cut where two bends meet at a corner of the base: round and rectangular a relief \@@ -110,7 +117,8 @@ pub static COMMANDS: &[CommandSpec] = &[left between the bend's sides, 180° less it; the bend table gives both, and a flange's `angle` is always the bend angle); \active?: bool; delete?: bool",),- CommandSpec::new("sheet.rules", "List Sheet Metal Rules", list_rules).icon("sheet_rules").noundo().doc_only().params("→ rules with their expressions and values, and the active one"),+ CommandSpec::new("sheet.rules", "List Sheet Metal Rules", crate::checked!("sheet.rules", list_rules))+ .contract(&RULES_CONTRACT).output(output_schema_for::<RulesResult>).icon("sheet_rules").noundo().doc_only().params("→ rules with their expressions and values, and the active one"),CommandSpec::new("sheet.flat_pattern", "Create Flat Pattern", flat_pattern).at("SHEET METAL", "CREATE").icon("flat")@@ -624,9 +632,13 @@ fn convert(s: &mut Session, p: &Value) -> Result<Value> {)}+pub(crate) fn sheet_rule_name(v: &Value) -> std::result::Result<&str, &'static str> {+ v.as_str().map(str::trim).filter(|n| !n.is_empty() && n.len() <= 128).ok_or("`name` is required")+}+fn rules(s: &mut Session, p: &Value) -> Result<Value> {let cmd = "sheet.manage_rules";- let name = str_(p, "name").map(str::trim).filter(|n| !n.is_empty() && n.len() <= 128).ok_or_else(|| bad(cmd, "`name` is required"))?.to_string();+ let name = sheet_rule_name(p.get("name").unwrap_or(&Value::Null)).map_err(|why| bad(cmd, why))?.to_string();if bool_(p, "delete").unwrap_or(false) {let doc = s.doc_mut();let before = doc.sheet.rules.len();@@ -637,7 +649,7 @@ fn rules(s: &mut Session, p: &Value) -> Result<Value> {if doc.sheet.active.as_deref() == Some(name.as_str()) {doc.sheet.active = None;}- return Ok(json!({"deleted": name}));+ return serde_json::to_value(ManageRulesResult::Deleted { deleted: name, param_warnings: Vec::new() }).map_err(|e| bad(cmd, e.to_string()));}let mut rule =s.doc.sheet.rules.iter().find(|r| r.name == name).cloned().unwrap_or_else(|| SheetRule { name: name.clone(), ..s.doc.sheet_rule(None) });@@ -670,18 +682,15 @@ fn rules(s: &mut Session, p: &Value) -> Result<Value> {doc.sheet.active = Some(name.clone());}s.refresh();- let errors: Vec<Value> = s.model.results.iter().filter_map(|r| r.error.as_ref().map(|e| json!({"feature": r.name, "error": e}))).collect();- Ok(json!({"rule": rule_json(&rule), "values": values, "errors": errors}))-}--/// A rule as the rule commands list it: as saved, and with its `angle_display` also while it is-/// the `bend` a design leaves out.-fn rule_json(r: &SheetRule) -> Value {- let mut v = json!(r);- if let Value::Object(m) = &mut v {- m.insert("angle_display".into(), json!(r.angle_display));- }- v+ let errors =+ s.model.results.iter().filter_map(|r| r.error.as_ref().map(|e| RuleFeatureError { feature: r.name.clone(), error: e.clone() })).collect();+ serde_json::to_value(ManageRulesResult::Changed {+ rule: Box::new(RuleReply::from(&rule)),+ values: values.into(),+ errors,+ param_warnings: Vec::new(),+ })+ .map_err(|e| bad(cmd, e.to_string()))}fn list_rules(s: &mut Session, _p: &Value) -> Result<Value> {@@ -690,9 +699,9 @@ fn list_rules(s: &mut Session, _p: &Value) -> Result<Value> {if all.is_empty() {all.push(SheetRule::steel());}- let rules: Vec<Value> = all.iter().map(|r| json!({"rule": rule_json(r), "values": s.doc.rule_values(&vals, r).ok()})).collect();+ let rules = all.iter().map(|r| ListedRule { rule: r.into(), values: s.doc.rule_values(&vals, r).ok().map(Into::into) }).collect();let active = s.doc.sheet_rule(None).name;- Ok(json!({"rules": rules, "active": active}))+ serde_json::to_value(RulesResult { rules, active, param_warnings: Vec::new() }).map_err(|e| bad("sheet.rules", e.to_string()))}fn no_sheet_body(cmd: &str) -> EngineError {diff --git a/crates/engine/src/schema/sheet.rs b/crates/engine/src/schema/sheet.rsindex da76fcba10..28022daf68 100644--- a/crates/engine/src/schema/sheet.rs+++ b/crates/engine/src/schema/sheet.rs@@ -1,5 +1,5 @@-//! Contracts for the sheet metal feature commands in `cmd/sheet.rs`. They all return-//! [`FeatureResult`](super::features::FeatureResult).+//! Contracts for sheet metal feature and rule commands in `cmd/sheet.rs`. Feature commands+//! return [`FeatureResult`](super::features::FeatureResult); rule commands have their own replies.//!//! A sheet metal rule sets the sheet's thickness, K-factor, bend radius and reliefs: the//! commands refuse those keys with a pointer to `sheet.manage_rules`, so they are no keys of@@ -557,6 +557,201 @@ pub struct ConvertParams {pub common: FeatureCommon,}+/// List the design's sheet metal rules (the built-in steel rule if none are saved).+#[derive(Debug, Deserialize, JsonSchema)]+#[schemars(deny_unknown_fields)]+pub struct RulesParams {}++/// Create or edit a sheet metal rule, activate it, or delete it. Expressions may use design+/// parameters; `Thickness` inside a rule's other expressions is that rule's thickness.+/// The handler evaluates dimensions and ranges against the design after checking the contract.+#[derive(Debug, Deserialize, JsonSchema)]+#[schemars(deny_unknown_fields)]+pub struct ManageRulesParams {+ /// The rule's name (trimmed, nonempty, at most 128 bytes). A new rule inherits the active+ /// rule's fields; an existing rule keeps fields not given here.+ pub name: RuleName,+ /// Thickness, more than 0 and less than 10000 mm. Ignored when deleting.+ pub thickness: Option<LengthExpr>,+ /// Neutral-axis fraction, from 0 to 1. Ignored when deleting.+ pub k_factor: Option<super::types::NumberExpr>,+ /// Inner bend radius, nonnegative. Ignored when deleting.+ pub bend_radius: Option<LengthExpr>,+ /// Bend relief width. Ignored when deleting.+ pub relief_width: Option<LengthExpr>,+ /// Bend relief depth. Ignored when deleting.+ pub relief_depth: Option<LengthExpr>,+ /// Corner relief size across. Ignored when deleting.+ pub corner_relief: Option<LengthExpr>,+ /// Corner relief shape. Ignored when deleting.+ pub corner_relief_shape: Option<ReliefShapeParam>,+ /// Inner radius of flat hems. Ignored when deleting.+ pub hem_gap: Option<LengthExpr>,+ /// Gap between meeting flanges. Ignored when deleting.+ pub gap: Option<LengthExpr>,+ /// How DXF bend notes show angles: bend or included, ignoring case and surrounding blanks.+ /// Ignored when deleting.+ pub angle_display: Option<AngleDisplayParam>,+ /// Make this the active rule. Default: true if there is no saved active rule, otherwise false.+ /// False leaves the active choice unchanged; ignored when deleting.+ pub active: Option<bool>,+ /// Delete the named saved rule instead of editing it. Default: false. Deleting the active+ /// rule clears that choice; listing then uses the first remaining rule, else built-in steel.+ pub delete: Option<bool>,+}++/// A rule name, checked by the handler's reader.+#[derive(Debug)]+pub struct RuleName(pub String);++impl<'de> Deserialize<'de> for RuleName {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ let v = Value::deserialize(d)?;+ crate::cmd::sheet_rule_name(&v).map(|n| RuleName(n.to_string())).map_err(|why| D::Error::custom(whole(why)))+ }+}++impl JsonSchema for RuleName {+ fn schema_name() -> Cow<'static, str> {+ "SheetRuleName".into()+ }+ fn json_schema(_: &mut SchemaGenerator) -> Schema {+ json_schema!({"type": "string", "description": "Trimmed, nonempty rule name, at most 128 bytes after trimming."})+ }+}++/// A rule's bend-note angle display, checked by the same parser as the handler.+#[derive(Debug)]+pub struct AngleDisplayParam(pub solidcraft_doc::sheet::AngleDisplay);++impl<'de> Deserialize<'de> for AngleDisplayParam {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ Value::deserialize(d)?+ .as_str()+ .and_then(solidcraft_doc::sheet::AngleDisplay::parse)+ .map(AngleDisplayParam)+ .ok_or_else(|| D::Error::custom("must be bend or included"))+ }+}++impl JsonSchema for AngleDisplayParam {+ fn schema_name() -> Cow<'static, str> {+ "SheetAngleDisplay".into()+ }+ fn json_schema(_: &mut SchemaGenerator) -> Schema {+ json_schema!({"type": "string", "description": "bend or included, ignoring case and surrounding blanks.",+ "pattern": format!("^{blank}([Bb][Ee][Nn][Dd]|[Ii][Nn][Cc][Ll][Uu][Dd][Ee][Dd]){blank}$", blank = blanks())})+ }+}++/// A saved rule's expressions, including the default bend-angle display which the saved+/// design omits. These are expressions, not evaluated values.+#[derive(Debug, serde::Serialize, JsonSchema)]+pub struct RuleReply {+ pub name: String,+ pub thickness: String,+ pub k_factor: String,+ pub bend_radius: String,+ pub relief_width: String,+ pub relief_depth: String,+ pub corner_relief: String,+ pub corner_relief_shape: String,+ pub hem_gap: String,+ pub gap: String,+ pub angle_display: String,+}++impl From<&solidcraft_doc::sheet::SheetRule> for RuleReply {+ fn from(r: &solidcraft_doc::sheet::SheetRule) -> Self {+ Self {+ name: r.name.clone(),+ thickness: r.thickness.clone(),+ k_factor: r.k_factor.clone(),+ bend_radius: r.bend_radius.clone(),+ relief_width: r.relief_width.clone(),+ relief_depth: r.relief_depth.clone(),+ corner_relief: r.corner_relief.clone(),+ corner_relief_shape: r.corner_relief_shape.clone(),+ hem_gap: r.hem_gap.clone(),+ gap: r.gap.clone(),+ angle_display: r.angle_display.clone(),+ }+ }+}++/// Evaluated rule values: lengths in millimetres, dimensionless K-factor and canonical choices.+#[derive(Debug, serde::Serialize, JsonSchema)]+pub struct RuleValuesReply {+ pub thickness: f64,+ pub k_factor: f64,+ pub bend_radius: f64,+ pub relief_width: f64,+ pub relief_depth: f64,+ pub corner_relief: f64,+ pub corner_relief_shape: String,+ pub hem_gap: f64,+ pub gap: f64,+ pub angle_display: String,+}++impl From<solidcraft_doc::sheet::RuleValues> for RuleValuesReply {+ fn from(r: solidcraft_doc::sheet::RuleValues) -> Self {+ Self {+ thickness: r.thickness,+ k_factor: r.k_factor,+ bend_radius: r.bend_radius,+ relief_width: r.relief_width,+ relief_depth: r.relief_depth,+ corner_relief: r.corner_relief,+ corner_relief_shape: r.corner_relief_shape.name().into(),+ hem_gap: r.hem_gap,+ gap: r.gap,+ angle_display: r.angle_display.name().into(),+ }+ }+}++/// A rule and its evaluated values, or null values if its expressions no longer evaluate.+#[derive(Debug, serde::Serialize, JsonSchema)]+pub struct ListedRule {+ pub rule: RuleReply,+ pub values: Option<RuleValuesReply>,+}++/// The rule list and effective active name.+#[derive(Debug, serde::Serialize, JsonSchema)]+pub struct RulesResult {+ pub rules: Vec<ListedRule>,+ pub active: String,+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub param_warnings: Vec<String>,+}++/// A feature that failed to rebuild after a rule was edited.+#[derive(Debug, serde::Serialize, JsonSchema)]+pub struct RuleFeatureError {+ pub feature: String,+ pub error: String,+}++/// A successful rule edit or deletion, preserving the existing reply alternatives.+#[derive(Debug, serde::Serialize, JsonSchema)]+#[serde(untagged)]+pub enum ManageRulesResult {+ Changed {+ rule: Box<RuleReply>,+ values: RuleValuesReply,+ errors: Vec<RuleFeatureError>,+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ param_warnings: Vec<String>,+ },+ Deleted {+ deleted: String,+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ param_warnings: Vec<String>,+ },+}+#[cfg(test)]#[path = "sheet_tests.rs"]mod tests;diff --git a/crates/engine/src/schema/sheet_tests.rs b/crates/engine/src/schema/sheet_tests.rsindex 1e1d50d3a8..6a63080f28 100644--- a/crates/engine/src/schema/sheet_tests.rs+++ b/crates/engine/src/schema/sheet_tests.rs@@ -355,3 +355,139 @@ fn replies_match_the_output_schema() {assert!(r.get("param_warnings").is_some(), "{r}");check(r);}++#[test]+fn rule_commands_publish_contracts_and_refuse_unknown_keys() {+ for id in ["sheet.rules", "sheet.manage_rules"] {+ let spec = crate::command_specs().into_iter().find(|c| c.id == id).unwrap();+ assert!(spec.contract.is_some() && spec.output.is_some(), "{id}: input schema missing");+ let mut s = Session { param_check: ParamCheck::Strict, ..Session::default() };+ let p = if id == "sheet.rules" { json!({"unknown_key": true}) } else { json!({"name": "Test", "thikness": 1}) };+ assert!(s.execute(id, &p).is_err(), "{id}: unknown key accepted");+ assert!(s.doc.sheet.rules.is_empty());+ }+}++#[test]+fn rule_contract_keys_and_readers_match() {+ use super::{AngleDisplayParam, ManageRulesParams, RuleName, RulesParams};+ assert_keys(input_schema_for::<RulesParams>(), &[]);+ assert_keys(+ input_schema_for::<ManageRulesParams>(),+ &[+ "active",+ "angle_display",+ "bend_radius",+ "corner_relief",+ "corner_relief_shape",+ "delete",+ "gap",+ "hem_gap",+ "k_factor",+ "name",+ "relief_depth",+ "relief_width",+ "thickness",+ ],+ );+ for (text, valid) in [("bend", true), (" INCLUDED ", true), ("\u{2003}BeNd\u{2003}", true), ("outside", false)] {+ assert_eq!(parse::<AngleDisplayParam>(json!(text)).is_some(), valid);+ }+ assert!(parse::<AngleDisplayParam>(json!(false)).is_none());+ for v in [json!(null), json!(false), json!(1), json!(""), json!(" \n "), json!("a".repeat(129)), json!("é".repeat(65))] {+ assert!(parse::<RuleName>(v).is_none());+ }+ assert_eq!(parse::<RuleName>(json!(" My rule ")).unwrap().0, "My rule");+ assert!(parse::<RuleName>(json!("é".repeat(64))).is_some());+ let pattern = input_schema_for::<AngleDisplayParam>();+ assert!(pattern.as_value()["pattern"].as_str().unwrap().contains(&super::blanks()));+ assert_strict_keeps_todays_errors(&[+ ("sheet.manage_rules", json!({"name": null})),+ ("sheet.manage_rules", json!({"name": true})),+ ("sheet.manage_rules", json!({"name": " "})),+ ("sheet.manage_rules", json!({"name": "a".repeat(129)})),+ ("sheet.manage_rules", json!({"name": "R", "angle_display": "outer"})),+ ("sheet.manage_rules", json!({"name": "R", "angle_display": 5})),+ ("sheet.manage_rules", json!({"name": "R", "corner_relief_shape": "oval"})),+ ("sheet.manage_rules", json!({"name": "R", "thickness": -1})),+ ("sheet.manage_rules", json!({"name": "R", "k_factor": 2})),+ ("sheet.manage_rules", json!({"name": "Missing", "delete": true})),+ ]);+}++/// Run all rule forms in Warn, compare with Off, and pin the successful reply shapes.+#[test]+fn rule_replies_match_the_output_schemas_without_warnings() {+ use super::{ManageRulesResult, RulesResult};+ let mut off = Session::default();+ let mut warn = Session { param_check: ParamCheck::Warn, ..Session::default() };+ let calls = [+ ("sheet.rules", json!({})),+ (+ "sheet.manage_rules",+ json!({"name": " Metric ", "thickness": 2, "k_factor": "0.4", "bend_radius": "Thickness / 2",+ "relief_width": 1, "relief_depth": "Thickness", "corner_relief": 3, "corner_relief_shape": " Round ",+ "hem_gap": 0.1, "gap": "Thickness / 2", "angle_display": " INCLUDED ", "active": true}),+ ),+ (+ "sheet.manage_rules",+ json!({"name": "Metric", "thickness": "3 mm", "k_factor": 0.5, "bend_radius": 1,+ "relief_width": "1 mm", "relief_depth": 2, "corner_relief": "3 mm", "corner_relief_shape": "tear",+ "hem_gap": "0.2 mm", "gap": 2, "angle_display": "BeNd", "active": false, "delete": false}),+ ),+ ("sheet.manage_rules", json!({"name": "Other"})),+ (+ "sheet.manage_rules",+ json!({"name": "Other", "thickness": null, "k_factor": null, "bend_radius": null,+ "relief_width": null, "relief_depth": null, "corner_relief": null, "corner_relief_shape": null,+ "hem_gap": null, "gap": null, "angle_display": null, "active": null, "delete": null}),+ ),+ ("sheet.rules", json!({})),+ ("sheet.manage_rules", json!({"name": "Other", "active": true})),+ ("sheet.manage_rules", json!({"name": "Metric", "delete": true})),+ ("sheet.manage_rules", json!({"name": "Other", "delete": true})),+ ("sheet.rules", json!({})),+ ];+ for (id, p) in calls {+ let a = off.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));+ let b = warn.execute(id, &p).unwrap_or_else(|e| panic!("{id} {p}: {e}"));+ assert_eq!(a, b, "{id} {p}");+ assert!(b.get("param_warnings").is_none(), "{id} {p}: {b}");+ let schema = if id == "sheet.rules" { output_schema_for::<RulesResult>() } else { output_schema_for::<ManageRulesResult>() };+ assert!(conforms(schema.as_value(), schema.as_value(), &b), "{id}: {b}");+ if let Some(rule) = b.get("rule") {+ let saved = off.doc.sheet.rules.iter().find(|r| json!(r.name) == rule["name"]).unwrap();+ let mut old = json!(saved);+ old["angle_display"] = json!(saved.angle_display);+ assert_eq!(*rule, old);+ let (vals, _) = off.doc.param_values();+ assert_eq!(b["values"], json!(off.doc.rule_values(&vals, saved).unwrap()));+ assert_eq!(b["errors"], json!([]));+ }+ }+ // Saved rules whose expressions no longer evaluate are still listed, with null values.+ warn.doc_mut().sheet.rules.push(solidcraft_doc::sheet::SheetRule {+ name: "Invalid".into(),+ thickness: "Missing".into(),+ ..solidcraft_doc::sheet::SheetRule::steel()+ });+ let reply = warn.execute("sheet.rules", &json!({})).unwrap();+ assert_eq!(reply["rules"][0]["values"], Value::Null);+ let schema = output_schema_for::<RulesResult>();+ assert!(conforms(schema.as_value(), schema.as_value(), &reply));+}++#[test]+fn rule_warnings_match_the_output_schema_and_strict_does_not_mutate() {+ use super::{ManageRulesResult, RulesResult};+ for (id, p) in [("sheet.rules", json!({"naem": "R"})), ("sheet.manage_rules", json!({"name": "R", "thikness": 1}))] {+ let mut s = Session { param_check: ParamCheck::Strict, ..Session::default() };+ assert!(s.execute(id, &p).is_err());+ assert!(s.doc.sheet.rules.is_empty());+ s.param_check = ParamCheck::Warn;+ let reply = s.execute(id, &p).unwrap();+ assert!(!reply["param_warnings"].as_array().unwrap().is_empty());+ let schema = if id == "sheet.rules" { output_schema_for::<RulesResult>() } else { output_schema_for::<ManageRulesResult>() };+ assert!(conforms(schema.as_value(), schema.as_value(), &reply));+ }+}diff --git a/crates/engine/src/schema/unconverted.txt b/crates/engine/src/schema/unconverted.txtindex c15dc2a167..80ecc747fd 100644--- a/crates/engine/src/schema/unconverted.txt+++ b/crates/engine/src/schema/unconverted.txt@@ -210,9 +210,7 @@ selection.deletesheet.export_bend_tablesheet.export_dxfsheet.flat_pattern-sheet.manage_rulessheet.path_flange-sheet.rulessketch.arc.center_pointsketch.arc.tangentsketch.arc.three_point