* Sketch Intersect: add Faces/Bodies and Projection Link options (#1110) Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Sketch Project: add Geometry/Bodies and Projection Link options (#1110) Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Sketch Project/Intersect: keep exact lines and arcs of whole bodies, no noisy rebuild warning (#1110) Whole-body silhouettes and sections fit lines and arcs tightly and snap arcs tangent to their neighbours. A rebuilt projection warns only when it removed the user's own constraints or curves. Pending locales cover ar, he and vi, and the preselection tests use the direct-pick workflow. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> * Select Other: label curves from Intersect as intersected (#1110) Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --------- Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
1 parent
420dff36c8
commit
162b3cd4ed
18 files changed
+681
-38
No files matched your search
@@ -0,0 +1,66 @@
|
||||
{
|
||||
"en": {
|
||||
"prefs.project_options_dialog": "Project options dialog",
|
||||
"prefs.project_options_dialog_note": "On: choose Geometry or Bodies and Projection Link before projecting. Off: keep the previous direct-pick workflow.",
|
||||
"ui.sketch_intersect_geometry": "Geometry",
|
||||
"ui.sketch_intersect_selection_filter": "Selection Filter",
|
||||
"ui.sketch_intersect_projection_link": "Projection Link",
|
||||
"ui.sketch_project_geometry": "Geometry"
|
||||
},
|
||||
"ja": {
|
||||
"prefs.project_options_dialog": "Projectのオプションダイアログ",
|
||||
"prefs.project_options_dialog_note": "オン: 投影前に「ジオメトリ」または「ボディ」と「投影リンク」を選択します。オフ: 従来の直接選択方式を使用します。",
|
||||
"ui.sketch_intersect_geometry": "ジオメトリ",
|
||||
"ui.sketch_intersect_selection_filter": "選択フィルター",
|
||||
"ui.sketch_intersect_projection_link": "投影リンク",
|
||||
"ui.sketch_project_geometry": "ジオメトリ"
|
||||
},
|
||||
"zh": {
|
||||
"prefs.project_options_dialog": "Project 选项对话框",
|
||||
"prefs.project_options_dialog_note": "开启:投影前选择“几何体”或“实体”以及“投影链接”。关闭:保留原有的直接选择工作流。",
|
||||
"ui.sketch_intersect_geometry": "几何体",
|
||||
"ui.sketch_intersect_selection_filter": "选择过滤器",
|
||||
"ui.sketch_intersect_projection_link": "投影链接",
|
||||
"ui.sketch_project_geometry": "几何体"
|
||||
},
|
||||
"ar": {
|
||||
"prefs.project_options_dialog": "مربع حوار خيارات Project",
|
||||
"prefs.project_options_dialog_note": "تشغيل: اختر الهندسة أو الأجسام ورابط الإسقاط قبل الإسقاط. إيقاف: الإبقاء على سير العمل السابق بالاختيار المباشر.",
|
||||
"ui.sketch_intersect_geometry": "الهندسة",
|
||||
"ui.sketch_intersect_selection_filter": "مرشح التحديد",
|
||||
"ui.sketch_intersect_projection_link": "رابط الإسقاط",
|
||||
"ui.sketch_project_geometry": "الهندسة"
|
||||
},
|
||||
"he": {
|
||||
"prefs.project_options_dialog": "תיבת האפשרויות של Project",
|
||||
"prefs.project_options_dialog_note": "פעיל: לבחור גאומטריה או גופים וקישור הטלה לפני ההטלה. כבוי: להשאיר את זרימת העבודה הקודמת של בחירה ישירה.",
|
||||
"ui.sketch_intersect_geometry": "גאומטריה",
|
||||
"ui.sketch_intersect_selection_filter": "מסנן בחירה",
|
||||
"ui.sketch_intersect_projection_link": "קישור הטלה",
|
||||
"ui.sketch_project_geometry": "גאומטריה"
|
||||
},
|
||||
"vi": {
|
||||
"prefs.project_options_dialog": "Hộp thoại tùy chọn Project",
|
||||
"prefs.project_options_dialog_note": "Bật: chọn Hình học hoặc Thân và Liên kết chiếu trước khi chiếu. Tắt: giữ quy trình chọn trực tiếp trước đây.",
|
||||
"ui.sketch_intersect_geometry": "Hình học",
|
||||
"ui.sketch_intersect_selection_filter": "Bộ lọc lựa chọn",
|
||||
"ui.sketch_intersect_projection_link": "Liên kết chiếu",
|
||||
"ui.sketch_project_geometry": "Hình học"
|
||||
},
|
||||
"de": {
|
||||
"prefs.project_options_dialog": "Project-Optionendialog",
|
||||
"prefs.project_options_dialog_note": "Ein: Vor dem Projizieren Geometrie oder Körper und die Projektionsverknüpfung auswählen. Aus: Den bisherigen Direktwahl-Ablauf beibehalten.",
|
||||
"ui.sketch_intersect_geometry": "Geometrie",
|
||||
"ui.sketch_intersect_selection_filter": "Auswahlfilter",
|
||||
"ui.sketch_intersect_projection_link": "Projektionsverknüpfung",
|
||||
"ui.sketch_project_geometry": "Geometrie"
|
||||
},
|
||||
"ko": {
|
||||
"prefs.project_options_dialog": "Project 옵션 대화상자",
|
||||
"prefs.project_options_dialog_note": "켜기: 투영 전에 지오메트리 또는 바디와 투영 링크를 선택합니다. 끄기: 기존 직접 선택 작업 흐름을 유지합니다.",
|
||||
"ui.sketch_intersect_geometry": "형상",
|
||||
"ui.sketch_intersect_selection_filter": "선택 필터",
|
||||
"ui.sketch_intersect_projection_link": "투영 링크",
|
||||
"ui.sketch_project_geometry": "형상"
|
||||
}
|
||||
}
|
||||
+123
-19
@@ -729,9 +729,14 @@ fn refresh_links_in(
|
||||
// Words built from text parameters change shape when the parameters do: that
|
||||
// rebuild is the text following them, not a reference that changed under it.
|
||||
let words_follow = matches!(&l.source, LinkSource::Text { exprs, .. } if exprs.text.is_some());
|
||||
let others = |sk: &Sketch| (sk.constraints.len(), sk.curves.len().saturating_sub(sk.link_curves(&l.id).len()));
|
||||
let before = others(sk);
|
||||
match sk.update_link(&l.id, &r.geom) {
|
||||
Ok(true) if words_follow => {}
|
||||
Ok(true) => warn.push(format!("projected {} changed shape and was rebuilt", l.source.describe())),
|
||||
// A rebuilt projection is only worth a warning when it took something of
|
||||
// the user's with it: a constraint, a dimension or a curve drawn on it.
|
||||
Ok(true) if others(sk) == before => {}
|
||||
Ok(true) => warn.push(format!("projected {} changed shape and was rebuilt; constraints on it were removed", l.source.describe())),
|
||||
Ok(false) if r.moved => warn.push(format!("projected {} was re-found on the nearest geometry", l.source.describe())),
|
||||
Ok(false) => {}
|
||||
Err(e) => {
|
||||
@@ -1079,7 +1084,7 @@ fn silhouette(plane: &Plane, m: &Mesh) -> Vec<LinkGeom> {
|
||||
})
|
||||
.map(|(a, b, _)| (plane.to_local(*a), plane.to_local(*b)))
|
||||
.collect();
|
||||
fit_segments(&segs, size)
|
||||
fit_segments(&segs, size, true)
|
||||
}
|
||||
|
||||
/// Section of a mesh (or one of its faces) with the sketch plane.
|
||||
@@ -1088,7 +1093,13 @@ pub(crate) fn section(plane: &Plane, m: &Mesh, face: Option<u32>) -> Vec<LinkGeo
|
||||
let (segs, exact) = section_segments(plane, m, face);
|
||||
let segs: Vec<(Vec2, Vec2)> = segs.into_iter().map(|(a, b, _)| (a, b)).collect();
|
||||
let loose = size * 2e-3;
|
||||
fit_segments(&segs, size).into_iter().map(|g| refine_round(g, &exact, loose)).collect()
|
||||
let refine = |v: Vec<LinkGeom>| -> Vec<LinkGeom> { v.into_iter().map(|g| refine_round(g, &exact, loose)).collect() };
|
||||
let lossy = refine(fit_segments(&segs, size, false));
|
||||
// Lines and arcs that follow the section closely (the corners of a rounded profile stay
|
||||
// where they are) are kept when they take no more curves than the loose fit.
|
||||
let close = refine(fit_segments(&segs, size, true));
|
||||
let plain = |v: &[LinkGeom]| v.iter().all(|g| matches!(g, LinkGeom::Line(..) | LinkGeom::Arc { .. } | LinkGeom::Circle(..)));
|
||||
if plain(&close) && close.len() <= lossy.len() { close } else { lossy }
|
||||
}
|
||||
|
||||
/// The segments where the plane crosses the mesh's triangles (in plane coordinates, each with
|
||||
@@ -1253,9 +1264,11 @@ fn refine_round(g: LinkGeom, exact: &[Vec2], tol: f64) -> LinkGeom {
|
||||
}
|
||||
|
||||
/// Chain loose 2D segments into polylines (merging coincident ends) and fit each chain.
|
||||
fn fit_segments(segs: &[(Vec2, Vec2)], size: f64) -> Vec<LinkGeom> {
|
||||
fn fit_segments(segs: &[(Vec2, Vec2)], size: f64, preserve_arcs: bool) -> Vec<LinkGeom> {
|
||||
// Mesh chords stray from the surface by up to the display tolerance (1/1000 of the size).
|
||||
let loose = Some(size * 2e-3);
|
||||
// A silhouette's vertices lie on the surface, so it is fitted tightly: a loose fit lets a line
|
||||
// swallow the start of a tangent arc, or an arc run on into the straight edge after it.
|
||||
let loose = Some(if preserve_arcs { size * 1e-5 } else { size * 2e-3 });
|
||||
let q = size * 1e-7;
|
||||
let key = |p: Vec2| ((p.x / q).round() as i64, (p.y / q).round() as i64);
|
||||
let mut nodes: BTreeMap<(i64, i64), (Vec2, Vec<usize>)> = BTreeMap::new();
|
||||
@@ -1303,19 +1316,96 @@ fn fit_segments(segs: &[(Vec2, Vec2)], size: f64) -> Vec<LinkGeom> {
|
||||
for s in starts {
|
||||
while nodes.get(&s).is_some_and(|n| n.1.iter().any(|e| !used.get(*e).copied().unwrap_or(true))) {
|
||||
let c = walk(s, &mut used);
|
||||
fit_chain(&c, loose, &mut out);
|
||||
fit_chain_with_arcs(&c, loose, &mut out, preserve_arcs);
|
||||
}
|
||||
}
|
||||
let keys: Vec<(i64, i64)> = nodes.keys().copied().collect();
|
||||
for s in keys {
|
||||
while nodes.get(&s).is_some_and(|n| n.1.iter().any(|e| !used.get(*e).copied().unwrap_or(true))) {
|
||||
let c = walk(s, &mut used);
|
||||
fit_chain(&c, loose, &mut out);
|
||||
fit_chain_with_arcs(&c, loose, &mut out, preserve_arcs);
|
||||
}
|
||||
}
|
||||
if preserve_arcs {
|
||||
snap_tangent_arcs(&mut out, size * 1e-3);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// A fitted arc is only a least-squares circle: make it exactly tangent to the straight edges
|
||||
/// it runs into, ending on them where they touch it, with one radius.
|
||||
fn snap_tangent_arcs(out: &mut [LinkGeom], tol: f64) {
|
||||
for i in 0..out.len() {
|
||||
let Some(LinkGeom::Arc { c, a, b }) = out.get(i).cloned() else { continue };
|
||||
let r = (c.dist(a) + c.dist(b)) / 2.0;
|
||||
// (arc end, line index, line end index, tangent point, unit normal towards the centre, centre distance)
|
||||
let mut hits: Vec<(usize, usize, usize, Vec2, Vec2, f64)> = Vec::new();
|
||||
for (end, e) in [a, b].into_iter().enumerate() {
|
||||
for (j, g) in out.iter().enumerate() {
|
||||
let LinkGeom::Line(p, q) = g else { continue };
|
||||
let Some(u) = (*q - *p).normalized() else { continue };
|
||||
let foot = *p + u * (c - *p).dot(u);
|
||||
let d = c.dist(foot);
|
||||
if (d - r).abs() > tol || foot.dist(e) > 0.5 * r {
|
||||
continue;
|
||||
}
|
||||
let Some(n) = (c - foot).normalized() else { continue };
|
||||
// The end of the line nearest the arc, and the tangent point must lie before it.
|
||||
let (near, far) = if p.dist(e) <= q.dist(e) { (0, *q) } else { (1, *p) };
|
||||
let near_pt = if near == 0 { *p } else { *q };
|
||||
// The line must itself end next to the arc: not just lie on the same infinite line.
|
||||
if (foot - far).dot(near_pt - far) <= 0.0 || near_pt.dist(foot) > 0.25 * r {
|
||||
continue;
|
||||
}
|
||||
hits.push((end, j, near, foot, n, d));
|
||||
}
|
||||
}
|
||||
let mut hits_by_end: [Option<(usize, usize, Vec2, Vec2, f64)>; 2] = [None, None];
|
||||
for (end, j, near, foot, n, d) in hits {
|
||||
if let Some(slot) = hits_by_end.get_mut(end)
|
||||
&& slot.is_none()
|
||||
{
|
||||
*slot = Some((j, near, foot, n, d));
|
||||
}
|
||||
}
|
||||
let (mut c, mut r) = (c, r);
|
||||
if let [Some((_, _, _, n1, d1)), Some((_, _, _, n2, d2))] = hits_by_end {
|
||||
// One circle tangent to both lines: equal distance to each.
|
||||
let det = n1.cross(n2);
|
||||
if det.abs() > 1e-6 {
|
||||
let m = (d1 + d2) / 2.0;
|
||||
let (r1, r2) = (m - d1, m - d2);
|
||||
let delta = Vec2::new((r1 * n2.y - r2 * n1.y) / det, (n1.x * r2 - n2.x * r1) / det);
|
||||
c += delta;
|
||||
r = m;
|
||||
}
|
||||
} else if let [Some((_, _, _, _, d)), None] | [None, Some((_, _, _, _, d))] = hits_by_end {
|
||||
r = d;
|
||||
}
|
||||
let on = |q: Vec2| c + (q - c).normalized().unwrap_or(Vec2::X) * r;
|
||||
let (mut na, mut nb) = (on(a), on(b));
|
||||
for (end, hit) in hits_by_end.into_iter().enumerate() {
|
||||
let Some((j, near, _, n, _)) = hit else { continue };
|
||||
let t = c - n * r;
|
||||
if let Some(LinkGeom::Line(p, q)) = out.get_mut(j) {
|
||||
if near == 0 {
|
||||
*p = t;
|
||||
} else {
|
||||
*q = t;
|
||||
}
|
||||
}
|
||||
if end == 0 {
|
||||
na = t;
|
||||
} else {
|
||||
nb = t;
|
||||
}
|
||||
}
|
||||
if let Some(LinkGeom::Arc { c: cc, a: aa, b: bb }) = out.get_mut(i) {
|
||||
(*cc, *aa, *bb) = (c, na, nb);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
// Fitting
|
||||
|
||||
@@ -1392,9 +1482,9 @@ fn fits_line(p: &[Vec2], tol: f64) -> bool {
|
||||
/// Circle through the chain (centre, radius, signed sweep from the first to the last point).
|
||||
/// `exact`: the points lie on the curve (edge tessellation), else they are approximate
|
||||
/// (mesh sections and silhouettes) and the circle is a least-squares fit.
|
||||
fn fits_circle(p: &[Vec2], tol: f64, exact: bool) -> Option<(Vec2, f64, f64)> {
|
||||
fn fits_circle(p: &[Vec2], tol: f64, exact: bool, preserve_arcs: bool) -> Option<(Vec2, f64, f64)> {
|
||||
let n = p.len();
|
||||
if n < 3 || (!exact && n < 5) {
|
||||
if n < 3 || (!exact && !preserve_arcs && n < 5) {
|
||||
return None;
|
||||
}
|
||||
let closed = p.first()?.dist(*p.last()?) <= tol;
|
||||
@@ -1442,6 +1532,10 @@ fn arc_geom(p: &[Vec2], c: Vec2, r: f64, sweep: f64, tol: f64) -> Option<LinkGeo
|
||||
/// else greedy maximal pieces. `loose`: the points are approximate (within `loose` mm), and
|
||||
/// sharp corners always split the chain.
|
||||
pub(crate) fn fit_chain(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom>) {
|
||||
fit_chain_with_arcs(raw, loose, out, false);
|
||||
}
|
||||
|
||||
fn fit_chain_with_arcs(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom>, preserve_arcs: bool) {
|
||||
let mut p: Vec<Vec2> = Vec::with_capacity(raw.len());
|
||||
let scale = raw.iter().fold(0.0_f64, |m, q| m.max(q.x.abs()).max(q.y.abs())).max(1.0);
|
||||
let ext = match (
|
||||
@@ -1491,10 +1585,12 @@ pub(crate) fn fit_chain(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom
|
||||
_ => 0.0,
|
||||
}
|
||||
};
|
||||
let corners: Vec<usize> = (0..n).filter(|i| turn(*i) > 30f64.to_radians()).collect();
|
||||
// A coarsely tessellated round turns up to ~35 degrees per chord; keep those together.
|
||||
let corner_turn = if preserve_arcs { 50f64 } else { 30f64 }.to_radians();
|
||||
let corners: Vec<usize> = (0..n).filter(|i| turn(*i) > corner_turn).collect();
|
||||
let cut = |a: usize, b: usize, out: &mut Vec<LinkGeom>| {
|
||||
if let Some(s) = p.get(a..=b) {
|
||||
fit_piece(s, tol, exact, out);
|
||||
fit_piece(s, tol, exact, preserve_arcs, out);
|
||||
}
|
||||
};
|
||||
if closed && let Some(&c0) = corners.first() {
|
||||
@@ -1508,7 +1604,7 @@ pub(crate) fn fit_chain(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom
|
||||
let mut start = 0;
|
||||
for c in cs.into_iter().chain([m - 1]) {
|
||||
if let Some(s) = q.get(start..=c) {
|
||||
fit_piece(s, tol, exact, out);
|
||||
fit_piece(s, tol, exact, preserve_arcs, out);
|
||||
}
|
||||
start = c;
|
||||
}
|
||||
@@ -1521,22 +1617,30 @@ pub(crate) fn fit_chain(raw: &[Vec2], loose: Option<f64>, out: &mut Vec<LinkGeom
|
||||
}
|
||||
return;
|
||||
}
|
||||
fit_piece(&p, tol, exact, out);
|
||||
fit_piece(&p, tol, exact, preserve_arcs, out);
|
||||
}
|
||||
|
||||
fn fit_piece(p: &[Vec2], tol: f64, exact: bool, out: &mut Vec<LinkGeom>) {
|
||||
fn fit_piece(p: &[Vec2], tol: f64, exact: bool, preserve_arcs: bool, out: &mut Vec<LinkGeom>) {
|
||||
if p.len() < 2 {
|
||||
return;
|
||||
}
|
||||
// A near-straight run is a line, not an arc of huge radius.
|
||||
let curved = |sw: f64| !preserve_arcs || exact || sw.abs() >= 20f64.to_radians();
|
||||
let fitted_arc = || fits_circle(p, tol, exact, preserve_arcs).filter(|(_, _, sw)| curved(*sw)).and_then(|(c, r, sw)| arc_geom(p, c, r, sw, tol));
|
||||
if preserve_arcs
|
||||
&& (exact || p.len() >= 4)
|
||||
&& let Some(g) = fitted_arc()
|
||||
{
|
||||
out.push(g);
|
||||
return;
|
||||
}
|
||||
if fits_line(p, tol) {
|
||||
if let (Some(a), Some(b)) = (p.first(), p.last()) {
|
||||
out.push(LinkGeom::Line(*a, *b));
|
||||
}
|
||||
return;
|
||||
}
|
||||
if let Some((c, r, sw)) = fits_circle(p, tol, exact)
|
||||
&& let Some(g) = arc_geom(p, c, r, sw, tol)
|
||||
{
|
||||
if !preserve_arcs && let Some(g) = fitted_arc() {
|
||||
out.push(g);
|
||||
return;
|
||||
}
|
||||
@@ -1553,7 +1657,7 @@ fn fit_piece(p: &[Vec2], tol: f64, exact: bool, out: &mut Vec<LinkGeom>) {
|
||||
let mut jc = i + 1;
|
||||
let mut arc = None;
|
||||
while jc + 1 < n {
|
||||
match p.get(i..=jc + 1).and_then(|s| fits_circle(s, tol, exact)) {
|
||||
match p.get(i..=jc + 1).and_then(|s| fits_circle(s, tol, exact, preserve_arcs)) {
|
||||
Some(f) => {
|
||||
arc = Some(f);
|
||||
jc += 1;
|
||||
@@ -1563,7 +1667,7 @@ fn fit_piece(p: &[Vec2], tol: f64, exact: bool, out: &mut Vec<LinkGeom>) {
|
||||
}
|
||||
if jc >= jl + 2
|
||||
&& jc - i >= 3
|
||||
&& let Some((c, r, sw)) = arc
|
||||
&& let Some((c, r, sw)) = arc.filter(|(_, _, sw)| curved(*sw))
|
||||
&& let Some(g) = p.get(i..=jc).and_then(|s| arc_geom(s, c, r, sw, tol))
|
||||
{
|
||||
out.push(g);
|
||||
|
||||
@@ -206,6 +206,35 @@ mod tests {
|
||||
assert!(family_edges(&mesh, &selected, &Plane::XY).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn coarsely_tessellated_round_silhouette_fits_an_arc() {
|
||||
use solidcraft_geom::Vec2;
|
||||
use solidcraft_sketch::LinkGeom;
|
||||
let on = |deg: f64| Vec2::new(5. + 5. * deg.to_radians().cos(), 5. + 5. * deg.to_radians().sin());
|
||||
let mut chain = vec![Vec2::new(0., -20.)];
|
||||
chain.extend([180., 169.5, 135., 100.5, 90.].map(on));
|
||||
chain.push(Vec2::new(45., 10.));
|
||||
let mut out = Vec::new();
|
||||
super::super::fit_chain_with_arcs(&chain, Some(0.05), &mut out, true);
|
||||
assert!(out.iter().any(|g| matches!(g, LinkGeom::Arc { .. })), "{out:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tangent_snapping_leaves_unrelated_collinear_lines_alone() {
|
||||
use solidcraft_geom::Vec2;
|
||||
use solidcraft_sketch::LinkGeom;
|
||||
let v = Vec2::new;
|
||||
// A rounded corner of radius 2 meeting the top edge, and an unrelated collinear edge.
|
||||
let mut out = vec![
|
||||
LinkGeom::Line(v(21., 8.), v(25., 8.)),
|
||||
LinkGeom::Arc { c: v(2.0008, 5.9992), a: v(2.2808, 8.0), b: v(0., 6.0) },
|
||||
LinkGeom::Line(v(2.0668, 8.), v(48., 8.)),
|
||||
];
|
||||
super::super::snap_tangent_arcs(&mut out, 0.05);
|
||||
assert_eq!(out.first(), Some(&LinkGeom::Line(v(21., 8.), v(25., 8.))));
|
||||
let (Some(LinkGeom::Arc { a, .. }), Some(LinkGeom::Line(p, _))) = (out.get(1), out.get(2)) else { panic!("{out:?}") };
|
||||
assert!(a.dist(*p) < 1e-9, "{out:?}");
|
||||
}
|
||||
#[test]
|
||||
fn boundaries_touching_at_a_vertex_project() {
|
||||
// Two squares of one face family meet only at the corner (1, 1): four boundary edges meet
|
||||
|
||||
@@ -21,9 +21,11 @@ macro_rules! refs_doc {
|
||||
}
|
||||
|
||||
pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("sketch.project", "Project", project_cmd).at("SKETCH", "CREATE").icon("project").key("P").enabled(in_sketch).params(concat!(refs_doc!(), created_doc!())),
|
||||
CommandSpec::new("sketch.project", "Project", project_cmd).at("SKETCH", "CREATE").icon("project").key("P").enabled(in_sketch).params(
|
||||
concat!(refs_doc!(), "; projection_link?: bool (default true)", created_doc!()),
|
||||
),
|
||||
CommandSpec::new("sketch.intersect", "Intersect", intersect_cmd).at("SKETCH", "CREATE").icon("intersect").enabled(in_sketch).params(
|
||||
concat!("refs: [{body}, {face: [x,y,z], body?}, {edge: [x,y,z], body?}, {sketch, curve}]: section curves (or points) with the sketch plane, linked", created_doc!()),
|
||||
concat!("refs: [{body}, {face: [x,y,z], body?}, {edge: [x,y,z], body?}, {sketch, curve}]: section curves (or points) with the sketch plane; projection_link?: bool (default true)", created_doc!()),
|
||||
),
|
||||
CommandSpec::new("sketch.include_3d", "Include 3D Geometry", include_cmd)
|
||||
.at("SKETCH", "CREATE")
|
||||
@@ -307,7 +309,7 @@ fn link_json(sk: &Sketch, link: &str) -> Value {
|
||||
json!({"link": link, "curves": curves, "points": points})
|
||||
}
|
||||
|
||||
fn run_links(s: &mut Session, p: &Value, cmd: &str, kind: LinkKind) -> Result<Value> {
|
||||
fn run_links(s: &mut Session, p: &Value, cmd: &str, kind: LinkKind, projection_link: bool) -> Result<Value> {
|
||||
let refs: Vec<Value> = match p.get("refs").or_else(|| p.get("ref")) {
|
||||
Some(Value::Array(a)) => a.iter().take(1000).cloned().collect(),
|
||||
Some(v) => vec![v.clone()],
|
||||
@@ -327,7 +329,14 @@ fn run_links(s: &mut Session, p: &Value, cmd: &str, kind: LinkKind) -> Result<Va
|
||||
for src in sources {
|
||||
let what = src.describe();
|
||||
match add_link_unless_present(s, doc, id, sk, kind, src, kind == LinkKind::Project) {
|
||||
Ok(Some(l)) => out.push(link_json(sk, &l)),
|
||||
Ok(Some(l)) => {
|
||||
let mut result = link_json(sk, &l);
|
||||
if !projection_link {
|
||||
result["link"] = Value::Null;
|
||||
sk.break_link(&l)?;
|
||||
}
|
||||
out.push(result);
|
||||
}
|
||||
Ok(None) => present.push(what),
|
||||
Err(e) => return Err(bad(cmd, format!("{what}: {e}"))),
|
||||
}
|
||||
@@ -346,15 +355,25 @@ fn run_links(s: &mut Session, p: &Value, cmd: &str, kind: LinkKind) -> Result<Va
|
||||
}
|
||||
|
||||
fn project_cmd(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
run_links(s, p, "sketch.project", LinkKind::Project)
|
||||
let projection_link = match p.get("projection_link") {
|
||||
None => true,
|
||||
Some(Value::Bool(value)) => *value,
|
||||
Some(_) => return Err(bad("sketch.project", "`projection_link` must be a boolean")),
|
||||
};
|
||||
run_links(s, p, "sketch.project", LinkKind::Project, projection_link)
|
||||
}
|
||||
|
||||
fn intersect_cmd(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
run_links(s, p, "sketch.intersect", LinkKind::Intersect)
|
||||
let projection_link = match p.get("projection_link") {
|
||||
None => true,
|
||||
Some(Value::Bool(value)) => *value,
|
||||
Some(_) => return Err(bad("sketch.intersect", "`projection_link` must be a boolean")),
|
||||
};
|
||||
run_links(s, p, "sketch.intersect", LinkKind::Intersect, projection_link)
|
||||
}
|
||||
|
||||
fn include_cmd(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
run_links(s, p, "sketch.include_3d", LinkKind::Include)
|
||||
run_links(s, p, "sketch.include_3d", LinkKind::Include, true)
|
||||
}
|
||||
|
||||
/// A constraint's operands may be model geometry (#6348): an `{edge: [x,y,z], body?}` or
|
||||
|
||||
@@ -216,6 +216,20 @@ fn project_edges_bodies_sketches_and_origin() {
|
||||
assert!(s.execute("sketch.project", &json!({"refs": [{"plane": "XY"}]})).is_err(), "parallel plane projects to nothing");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn project_whole_body_can_create_unlinked_geometry() {
|
||||
let mut s = Session::default();
|
||||
box_part(&mut s);
|
||||
let sketch = run(&mut s, "sketch.create", json!({"plane":"XY"}))["sketch"].as_u64().unwrap();
|
||||
let body = s.model.state().bodies[0].name.clone();
|
||||
let r = run(&mut s, "sketch.project", json!({"refs":[{"body":body}],"projection_link":false}));
|
||||
assert_eq!(r["links"][0]["link"], Value::Null);
|
||||
let sk = s.doc.sketch(sketch).unwrap();
|
||||
assert!(sk.links.is_empty());
|
||||
assert_eq!(sk.curves.len(), 4);
|
||||
assert!(s.execute("sketch.project", &json!({"refs":[{"body":body}],"projection_link":"false"})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intersect_cuts_a_body_with_the_sketch_plane() {
|
||||
let mut s = Session::default();
|
||||
@@ -873,3 +887,199 @@ fn intersect_on_a_top_face_gives_its_outline() {
|
||||
ends.sort_by(|a, b| a.partial_cmp(b).unwrap());
|
||||
assert_eq!(ends, vec![[0.0, 0.0, 40.0, 0.0], [0.0, 30.0, 0.0, 0.0], [40.0, 0.0, 40.0, 30.0], [40.0, 30.0, 0.0, 30.0]]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intersect_whole_body_can_create_unlinked_section_geometry() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "Post"}));
|
||||
run(&mut s, "sketch.create", json!({"plane": "XY", "offset": 10}));
|
||||
|
||||
let result = run(&mut s, "sketch.intersect", json!({"refs": [{"body": "Post"}], "projection_link": false}));
|
||||
assert_eq!(result["links"][0]["link"], Value::Null, "{result}");
|
||||
assert_eq!(result["links"][0]["curves"].as_array().unwrap().len(), 4, "{result}");
|
||||
|
||||
let sketch = s.doc.sketch(s.active_sketch.unwrap()).unwrap();
|
||||
assert!(sketch.links.is_empty(), "projection links were disabled");
|
||||
assert_eq!(sketch.curves.len(), 4, "the whole body's section remains as normal sketch geometry");
|
||||
assert!(s.execute("sketch.intersect", &json!({"refs": [{"body": "Post"}], "projection_link": "false"})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn whole_body_project_preserves_the_arc_of_a_chamfered_round_edge() {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "Plate"}));
|
||||
run(&mut s, "solid.fillet", json!({"edges": [[40, 0, 10]], "radius": 5}));
|
||||
let sketch = run(&mut s, "sketch.create", json!({"plane": {"face": [20, 15, 20]}, "project_edges": false}))["sketch"].as_u64().unwrap();
|
||||
run(&mut s, "sketch.project", json!({"refs": [{"body": "Plate"}]}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
|
||||
run(&mut s, "timeline.roll_to", json!({"position": 2}));
|
||||
run(&mut s, "solid.chamfer", json!({"edges": [[40, 15, 20]], "distance": 1}));
|
||||
run(&mut s, "timeline.roll_to", json!({}));
|
||||
|
||||
let result = s.model.result(sketch).unwrap();
|
||||
let state = s.model.state();
|
||||
let solved = state.sketch(sketch).unwrap();
|
||||
let sketch = &solved.sketch;
|
||||
assert!(result.error.is_none(), "{:?}", result.error);
|
||||
assert!(result.warning.is_none(), "a rebuilt projection nothing depends on needs no warning: {:?}", result.warning);
|
||||
assert!((solved.plane.origin.z - 20.).abs() < 1e-6);
|
||||
assert!(
|
||||
sketch.curves.iter().any(|curve| matches!(curve.kind, solidcraft_sketch::CurveKind::Arc { .. })),
|
||||
"the rounded chamfer silhouette should contain an arc, not only line segments: {:?}",
|
||||
sketch.curves
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn whole_body_project_stays_on_the_body_outline_after_a_late_chamfer() {
|
||||
use solidcraft_sketch::CurveKind;
|
||||
let planes: [([i32; 3], &str); 3] = [([20, 15, 20], "top"), ([20, 0, 10], "front"), ([40, 15, 10], "side")];
|
||||
let chamfers: [[i32; 3]; 4] = [[40, 15, 20], [20, 0, 20], [40, 0, 10], [38, 2, 20]];
|
||||
for (face, plane) in planes {
|
||||
for chamfer in chamfers {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "Plate"}));
|
||||
run(&mut s, "solid.fillet", json!({"edges": [[40, 0, 10]], "radius": 5}));
|
||||
let sketch = run(&mut s, "sketch.create", json!({"plane": {"face": face}, "project_edges": false}))["sketch"].as_u64().unwrap();
|
||||
run(&mut s, "sketch.project", json!({"refs": [{"body": "Plate"}]}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
run(&mut s, "timeline.roll_to", json!({"position": 2}));
|
||||
if s.execute("solid.chamfer", &json!({"edges": [chamfer], "distance": 1})).is_err() {
|
||||
continue;
|
||||
}
|
||||
run(&mut s, "timeline.roll_to", json!({}));
|
||||
let state = s.model.state();
|
||||
let solved = state.sketch(sketch).unwrap();
|
||||
let sk = &solved.sketch;
|
||||
let pts: Vec<_> = sk.points.iter().map(|p| p.pos).collect();
|
||||
let (x0, x1) = pts.iter().fold((f64::MAX, f64::MIN), |a, p| (a.0.min(p.x), a.1.max(p.x)));
|
||||
let (y0, y1) = pts.iter().fold((f64::MAX, f64::MIN), |a, p| (a.0.min(p.y), a.1.max(p.y)));
|
||||
let mut worst = 0.0_f64;
|
||||
for curve in &sk.curves {
|
||||
if let CurveKind::Arc { c, a, b } = curve.kind {
|
||||
let (c, a, b) = (pts[c], pts[a], pts[b]);
|
||||
let r = c.dist(a);
|
||||
let (t0, mut sweep) = ((a - c).angle(), (b - c).angle() - (a - c).angle());
|
||||
while sweep < 0.0 {
|
||||
sweep += std::f64::consts::TAU;
|
||||
}
|
||||
for i in 0..=16 {
|
||||
let t = t0 + sweep * f64::from(i) / 16.0;
|
||||
let q = solidcraft_geom::Vec2::new(c.x + r * t.cos(), c.y + r * t.sin());
|
||||
worst = worst.max((x0 - q.x).max(q.x - x1).max(y0 - q.y).max(q.y - y1));
|
||||
}
|
||||
assert!(sweep < std::f64::consts::PI + 0.01, "{plane} {chamfer:?}: arc sweeps {sweep} rad, not a rounded corner");
|
||||
}
|
||||
}
|
||||
assert!(worst < 0.01, "{plane} {chamfer:?}: an arc leaves the body outline by {worst}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn whole_body_project_of_a_filleted_plate_keeps_exact_lines_and_arcs() {
|
||||
use solidcraft_sketch::CurveKind;
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 80, "width": 50, "height": 8, "body_name": "Plate"}));
|
||||
run(&mut s, "solid.fillet", json!({"edges": [[0, 0, 4], [80, 0, 4], [80, 50, 4], [0, 50, 4]], "radius": 6}));
|
||||
let sketch = run(&mut s, "sketch.create", json!({"plane": "YZ", "offset": 36, "project_edges": false}))["sketch"].as_u64().unwrap();
|
||||
run(&mut s, "sketch.project", json!({"refs": [{"body": "Plate"}]}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
run(&mut s, "timeline.roll_to", json!({"position": 2}));
|
||||
let top = [[40., 0.], [1.7574, 1.7574], [78.2426, 1.7574], [80., 25.], [78.2426, 48.2426], [40., 50.], [1.7574, 48.2426], [0., 25.]];
|
||||
let edges: Vec<_> = top.iter().map(|p| json!([p[0], p[1], 8])).collect();
|
||||
run(&mut s, "solid.fillet", json!({"edges": edges, "radius": 2}));
|
||||
run(&mut s, "timeline.roll_to", json!({}));
|
||||
|
||||
let state = s.model.state();
|
||||
let sk = &state.sketch(sketch).unwrap().sketch;
|
||||
let pos = |i: usize| sk.points[i].pos;
|
||||
let mut arcs = Vec::new();
|
||||
for curve in &sk.curves {
|
||||
match curve.kind {
|
||||
CurveKind::Line { a, b } => {
|
||||
let d = pos(b) - pos(a);
|
||||
assert!(d.x.abs() < 1e-3 || d.y.abs() < 1e-3, "slanted line {:?} -> {:?}", pos(a), pos(b));
|
||||
}
|
||||
CurveKind::Arc { c, a, .. } => arcs.push(pos(c).dist(pos(a))),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
assert_eq!(arcs.len(), 2, "{arcs:?}");
|
||||
assert!(arcs.iter().all(|r| (r - 2.).abs() < 5e-3), "{arcs:?}");
|
||||
// Every arc end is exactly the end of a straight edge, and meets it tangentially.
|
||||
for curve in &sk.curves {
|
||||
let CurveKind::Arc { c, a, b } = curve.kind else { continue };
|
||||
for end in [a, b] {
|
||||
let touching = sk
|
||||
.curves
|
||||
.iter()
|
||||
.filter(|o| matches!(o.kind, CurveKind::Line { a: p, b: q } if pos(p).dist(pos(end)) < 1e-6 || pos(q).dist(pos(end)) < 1e-6))
|
||||
.count();
|
||||
assert!(touching >= 1, "arc end {:?} meets no line end", pos(end));
|
||||
let radial = pos(end) - pos(c);
|
||||
assert!((radial.len() - 2.).abs() < 5e-3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn whole_body_intersect_of_a_filleted_plate_keeps_exact_lines_and_arcs() {
|
||||
use solidcraft_sketch::CurveKind;
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 80, "width": 50, "height": 8, "body_name": "Plate"}));
|
||||
let sketch = run(&mut s, "sketch.create", json!({"plane": "YZ", "offset": 36, "project_edges": false}))["sketch"].as_u64().unwrap();
|
||||
run(&mut s, "sketch.intersect", json!({"refs": [{"body": "Plate"}]}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
run(&mut s, "timeline.roll_to", json!({"position": 1}));
|
||||
let top = [[40., 0.], [80., 25.], [40., 50.], [0., 25.]];
|
||||
let edges: Vec<_> = top.iter().map(|p| json!([p[0], p[1], 8])).collect();
|
||||
run(&mut s, "solid.fillet", json!({"edges": edges, "radius": 2}));
|
||||
run(&mut s, "timeline.roll_to", json!({}));
|
||||
|
||||
let result = s.model.result(sketch).unwrap().warning.clone();
|
||||
assert!(result.is_none(), "{result:?}");
|
||||
let state = s.model.state();
|
||||
let sk = &state.sketch(sketch).unwrap().sketch;
|
||||
let pos = |i: usize| sk.points[i].pos;
|
||||
let mut arcs = Vec::new();
|
||||
for curve in &sk.curves {
|
||||
match curve.kind {
|
||||
CurveKind::Line { a, b } => {
|
||||
let d = pos(b) - pos(a);
|
||||
assert!(d.x.abs() < 1e-3 || d.y.abs() < 1e-3, "slanted line {:?} -> {:?}", pos(a), pos(b));
|
||||
}
|
||||
CurveKind::Arc { c, a, .. } => arcs.push(pos(c).dist(pos(a))),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
assert_eq!(sk.curves.len(), 6, "{} curves", sk.curves.len());
|
||||
assert_eq!(arcs.len(), 2, "{arcs:?}");
|
||||
assert!(arcs.iter().all(|r| (r - 2.).abs() < 5e-3), "{arcs:?}");
|
||||
}
|
||||
#[test]
|
||||
fn a_rebuilt_projection_keeps_user_constraints_without_a_warning() {
|
||||
for dimensioned in [false, true] {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "solid.box", json!({"length": 40, "width": 30, "height": 20, "body_name": "Plate"}));
|
||||
run(&mut s, "solid.fillet", json!({"edges": [[40, 0, 10]], "radius": 5}));
|
||||
let sketch = run(&mut s, "sketch.create", json!({"plane": {"face": [20, 15, 20]}, "project_edges": false}))["sketch"].as_u64().unwrap();
|
||||
run(&mut s, "sketch.project", json!({"refs": [{"body": "Plate"}]}));
|
||||
if dimensioned {
|
||||
// A line of the user's, pinned to the projected corner.
|
||||
let line = ids(&run(&mut s, "sketch.line", json!({"points": [[5, 5], [10, 5]]}))["curves"]);
|
||||
run(&mut s, "sketch.constraint.coincident", json!({"a": format!("{}.start", line[0]), "b": "p4"}));
|
||||
}
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
run(&mut s, "timeline.roll_to", json!({"position": 2}));
|
||||
run(&mut s, "solid.chamfer", json!({"edges": [[40, 15, 20]], "distance": 1}));
|
||||
run(&mut s, "timeline.roll_to", json!({}));
|
||||
let warning = s.model.result(sketch).unwrap().warning.clone();
|
||||
let st = s.model.state();
|
||||
let k = &st.sketch(sketch).unwrap().sketch;
|
||||
// The user's constraint survives the rebuild, so there is nothing to warn about.
|
||||
assert_eq!(k.constraints.len(), usize::from(dimensioned));
|
||||
assert!(warning.is_none(), "{warning:?}");
|
||||
}
|
||||
}
|
||||
@@ -608,9 +608,11 @@ pub fn find_drawn_profiles(sk: &Sketch) -> Vec<Profile> {
|
||||
if sk.links.iter().all(|l| l.kind == crate::LinkKind::Text) {
|
||||
return find_profiles(sk);
|
||||
}
|
||||
let intersect_links: std::collections::HashSet<&str> =
|
||||
sk.links.iter().filter(|link| link.kind == crate::LinkKind::Intersect).map(|link| link.id.as_str()).collect();
|
||||
let mut d = sk.clone();
|
||||
for (ci, c) in d.curves.iter_mut().enumerate() {
|
||||
if c.link.is_some() && !sk.is_text_curve(ci) {
|
||||
if c.link.as_ref().is_some_and(|link| !intersect_links.contains(link.as_str())) && !sk.is_text_curve(ci) {
|
||||
c.construction = true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -831,17 +831,19 @@ fn text_beside_other_curves_is_drawn_geometry() {
|
||||
}
|
||||
assert_areas(&sorted_areas(&find_drawn_profiles(&sk)), vec![13.5557, 600.0]);
|
||||
// Projected reference geometry still doesn't count as drawn.
|
||||
let square = |s: f64| {
|
||||
let square = |x: f64, s: f64| {
|
||||
vec![
|
||||
LinkGeom::Line(v(100.0, 0.0), v(100.0 + s, 0.0)),
|
||||
LinkGeom::Line(v(100.0 + s, 0.0), v(100.0 + s, s)),
|
||||
LinkGeom::Line(v(100.0 + s, s), v(100.0, s)),
|
||||
LinkGeom::Line(v(100.0, s), v(100.0, 0.0)),
|
||||
LinkGeom::Line(v(x, 0.0), v(x + s, 0.0)),
|
||||
LinkGeom::Line(v(x + s, 0.0), v(x + s, s)),
|
||||
LinkGeom::Line(v(x + s, s), v(x, s)),
|
||||
LinkGeom::Line(v(x, s), v(x, 0.0)),
|
||||
]
|
||||
};
|
||||
sk.add_link(LinkKind::Project, LinkSource::Origin, &square(5.0)).unwrap();
|
||||
sk.add_link(LinkKind::Project, LinkSource::Origin, &square(100.0, 5.0)).unwrap();
|
||||
assert_eq!(find_profiles(&sk).len(), 3);
|
||||
assert_areas(&sorted_areas(&find_drawn_profiles(&sk)), vec![13.5557, 600.0]);
|
||||
sk.add_link(LinkKind::Intersect, LinkSource::Origin, &square(110.0, 7.0)).unwrap();
|
||||
assert_areas(&sorted_areas(&find_drawn_profiles(&sk)), vec![13.5557, 49.0, 600.0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
@@ -97,6 +97,8 @@ const WALL_LABELS: [&str; 4] = ["Center", "Inside", "Outside", "Two Sides"];
|
||||
/// What an extrude's first input picks: profiles or planar faces, or curves too when thin.
|
||||
const EXTRUDE_ACCEPT: Accept = PROFILES | PLANAR_FACES;
|
||||
const THIN_ACCEPT: Accept = PROFILES | CURVES;
|
||||
const PROJECT_GEOMETRY: Accept =
|
||||
EDGES | FACES | selection::VERTICES | PLANES | AXES | selection::SKETCH_LINES | selection::EXTERNAL_POINTS | selection::ORIGIN;
|
||||
const HOLE_TYPES: [&str; 3] = ["simple", "counterbore", "countersink"];
|
||||
const HOLE_LABELS: [&str; 3] = ["Simple", "Counterbore", "Countersink"];
|
||||
|
||||
@@ -388,6 +390,14 @@ crate::dialog_descriptor::dialog_descriptors! {
|
||||
/// Sketch-space modify tools: scale and offset, and later fillet, chamfer, the patterns,
|
||||
/// mirror and move (`sketch_modify_ui`).
|
||||
SketchModify(crate::sketch_modify_ui::Mod),
|
||||
SketchIntersect {
|
||||
bodies: bool,
|
||||
projection_link: bool,
|
||||
},
|
||||
SketchProject {
|
||||
bodies: bool,
|
||||
projection_link: bool,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -797,6 +807,20 @@ impl Dialog {
|
||||
let has_bodies = !s.world_state().bodies.is_empty();
|
||||
let mut d = match id {
|
||||
"sketch.create" => Dialog::new(Kind::Sketch, vec![SelInput::new("Plane", PLANES | PLANAR_FACES, false)]),
|
||||
"sketch.intersect" => {
|
||||
let bodies = s.selection.iter().any(|sel| matches!(sel, Sel::Body { .. }));
|
||||
Dialog::new(
|
||||
Kind::SketchIntersect { bodies, projection_link: true },
|
||||
vec![SelInput::new("ui.sketch_intersect_geometry", if bodies { BODIES } else { FACES }, true)],
|
||||
)
|
||||
}
|
||||
"sketch.project" => {
|
||||
let bodies = s.selection.iter().any(|sel| matches!(sel, Sel::Body { .. }));
|
||||
Dialog::new(
|
||||
Kind::SketchProject { bodies, projection_link: true },
|
||||
vec![SelInput::new("ui.sketch_project_geometry", if bodies { BODIES } else { PROJECT_GEOMETRY }, true)],
|
||||
)
|
||||
}
|
||||
"solid.extrude" => Dialog::new(
|
||||
Kind::Extrude {
|
||||
distance: length_default(s, "10"),
|
||||
@@ -2122,6 +2146,8 @@ fn publish_check(ui: &egui::Ui, response: &egui::Response, selected: bool) {
|
||||
fn title(k: &Kind) -> &'static str {
|
||||
match k {
|
||||
Kind::Sketch => "CREATE SKETCH",
|
||||
Kind::SketchIntersect { .. } => "INTERSECT",
|
||||
Kind::SketchProject { .. } => "PROJECT",
|
||||
Kind::Extrude { .. } => "EXTRUDE",
|
||||
Kind::Revolve { .. } => "REVOLVE",
|
||||
Kind::Fillet { chamfer: false, .. } => "FILLET",
|
||||
@@ -4752,6 +4778,24 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S
|
||||
Kind::EditParam { name, expr } => ("parameters.change", json!({"name": name, "expression": expr})),
|
||||
Kind::Rename { feature, name } => ("timeline.rename", json!({"feature": feature, "name": name})),
|
||||
Kind::ConfirmDelete { features, groups, .. } => ("timeline.delete", crate::timeline::delete_params(features, groups)),
|
||||
Kind::SketchIntersect { projection_link, .. } => {
|
||||
need(0, "faces or bodies")?;
|
||||
let refs = sels(d, 0)
|
||||
.iter()
|
||||
.map(|sel| match sel {
|
||||
Sel::Body { name } => Ok(json!({"body": name})),
|
||||
Sel::Face { body, point, .. } => Ok(json!({"face": [point.x, point.y, point.z], "body": body})),
|
||||
_ => Err("select faces or bodies".to_string()),
|
||||
})
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
("sketch.intersect", json!({"refs": refs, "projection_link": projection_link}))
|
||||
}
|
||||
Kind::SketchProject { projection_link, .. } => {
|
||||
need(0, "geometry or bodies")?;
|
||||
let refs =
|
||||
crate::tools::projection_preselection(sels(d, 0)).ok_or_else(|| "select geometry or bodies that can be projected".to_string())?;
|
||||
("sketch.project", json!({"refs": refs, "projection_link": projection_link}))
|
||||
}
|
||||
Kind::Sketch | Kind::Measure { .. } => return Ok(Vec::new()),
|
||||
Kind::Assembly(k) => return crate::dialogs_assembly::commands(app, k, &d.inputs),
|
||||
Kind::Sheet(k) => return crate::dialogs_sheet::commands(app, k, &d.inputs, &d.extra),
|
||||
|
||||
@@ -19,6 +19,8 @@ pub(super) fn command(kind: &Kind) -> Option<&'static str> {
|
||||
Kind::ViewDxf { .. } => Some("file.export_view_dxf"),
|
||||
Kind::InsertDrawing(p) => Some(if p.command.ends_with("dxf") { "sketch.insert_dxf" } else { "sketch.insert_svg" }),
|
||||
Kind::Sketch => Some("sketch.create"),
|
||||
Kind::SketchIntersect { .. } => Some("sketch.intersect"),
|
||||
Kind::SketchProject { .. } => Some("sketch.project"),
|
||||
Kind::SketchModify(k) => Some(crate::sketch_modify_ui::command(k)),
|
||||
Kind::Text(_) => Some("sketch.edit_text"),
|
||||
Kind::TextMove(_) => Some("sketch.move"),
|
||||
@@ -212,6 +214,30 @@ pub(super) fn rows(app: &mut SolveApp, ctx: &egui::Context, d: &mut Dialog, ui:
|
||||
}
|
||||
}
|
||||
}
|
||||
Kind::SketchIntersect { bodies, projection_link } => {
|
||||
let mut selected = if *bodies { 1 } else { 0 };
|
||||
let changed = ui_kit::row(ui, tr("ui.sketch_intersect_selection_filter"), |ui| {
|
||||
ui_kit::segmented(ui, &mut selected, &[tr("Faces"), tr("Bodies")], Default::default())
|
||||
});
|
||||
if changed && let Some(input) = d.inputs.first_mut() {
|
||||
*bodies = selected == 1;
|
||||
input.accept = if *bodies { BODIES } else { FACES };
|
||||
input.items.clear();
|
||||
}
|
||||
ui_kit::row(ui, tr("ui.sketch_intersect_projection_link"), |ui| ui_kit::checkbox(ui, "", projection_link));
|
||||
}
|
||||
Kind::SketchProject { bodies, projection_link } => {
|
||||
let mut selected = if *bodies { 1 } else { 0 };
|
||||
let changed = ui_kit::row(ui, tr("ui.sketch_intersect_selection_filter"), |ui| {
|
||||
ui_kit::segmented(ui, &mut selected, &[tr("Geometry"), tr("Bodies")], Default::default())
|
||||
});
|
||||
if changed && let Some(input) = d.inputs.first_mut() {
|
||||
*bodies = selected == 1;
|
||||
input.accept = if *bodies { BODIES } else { super::PROJECT_GEOMETRY };
|
||||
input.items.clear();
|
||||
}
|
||||
ui_kit::row(ui, tr("ui.sketch_intersect_projection_link"), |ui| ui_kit::checkbox(ui, "", projection_link));
|
||||
}
|
||||
Kind::SketchModify(k) => enter |= crate::sketch_modify_ui::rows(ui, k, &app.session.doc),
|
||||
Kind::Text(k) => enter |= crate::sketch_text::rows(ui, k, &mut d.inputs, &mut d.active),
|
||||
Kind::TextMove(k) => enter |= crate::sketch_text_move::rows(ui, k),
|
||||
|
||||
@@ -101,6 +101,82 @@ fn create_sketch_uses_card_and_still_starts_immediately_on_plane_pick() {
|
||||
assert!(h.app.session.active_sketch.is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn intersect_dialog_filters_faces_or_whole_bodies_and_controls_projection_link() {
|
||||
let mut h = Harness::new();
|
||||
h.app.run("solid.box", json!({"length":40,"width":30,"height":20,"body_name":"Post"})).unwrap();
|
||||
h.app.run("sketch.create", json!({"plane":"XY","offset":10})).unwrap();
|
||||
h.app.session.selection = vec![Sel::Body { name: "Post".into() }];
|
||||
h.app.start("sketch.intersect");
|
||||
h.frames(4);
|
||||
|
||||
let d = h.app.dialog.as_ref().expect("Intersect opens an options dialog");
|
||||
assert!(matches!(d.kind, Kind::SketchIntersect { bodies: true, projection_link: true }));
|
||||
assert_eq!(d.inputs[0].accept, super::BODIES);
|
||||
assert_eq!(d.inputs[0].items, vec![Sel::Body { name: "Post".into() }]);
|
||||
assert!(scenario::rect_of("dialog:row:ui.sketch_intersect_geometry").is_some());
|
||||
assert!(scenario::handle_at("dialog:Selection Filter:Faces").is_some());
|
||||
assert!(scenario::handle_at("dialog:Selection Filter:Bodies").is_some());
|
||||
assert!(scenario::rect_of("dialog:row:Projection Link").is_some());
|
||||
|
||||
h.step(&json!({"click":{"handle":"dialog:Selection Filter:Faces"}})).unwrap();
|
||||
assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].accept, super::FACES);
|
||||
assert!(h.app.dialog.as_ref().unwrap().inputs[0].items.is_empty());
|
||||
h.step(&json!({"click":{"handle":"dialog:Selection Filter:Bodies"}})).unwrap();
|
||||
assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].accept, super::BODIES);
|
||||
h.step(&json!({"click":{"handle":"dialog:Projection Link"}})).unwrap();
|
||||
assert!(matches!(h.app.dialog.as_ref().unwrap().kind, Kind::SketchIntersect { projection_link: false, .. }));
|
||||
|
||||
{
|
||||
let d = h.app.dialog.as_mut().unwrap();
|
||||
d.inputs[0].items = vec![Sel::Body { name: "Post".into() }];
|
||||
}
|
||||
let d = h.app.dialog.as_ref().unwrap();
|
||||
assert_eq!(apply_commands(&h.app, d).unwrap(), vec![("sketch.intersect".into(), json!({"refs":[{"body":"Post"}],"projection_link":false}))]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn project_dialog_keeps_geometry_targets_and_can_project_whole_bodies_unlinked() {
|
||||
let mut h = Harness::new();
|
||||
h.app.run("solid.box", json!({"length":40,"width":30,"height":20,"body_name":"Plate"})).unwrap();
|
||||
h.app.run("sketch.create", json!({"plane":"XY","offset":10})).unwrap();
|
||||
h.app.session.selection = vec![Sel::Body { name: "Plate".into() }];
|
||||
h.app.start("sketch.project");
|
||||
h.frames(4);
|
||||
|
||||
let d = h.app.dialog.as_ref().expect("Project opens an options dialog");
|
||||
assert!(matches!(d.kind, Kind::SketchProject { bodies: true, projection_link: true }));
|
||||
assert_eq!(d.inputs[0].accept, super::BODIES);
|
||||
assert_eq!(d.inputs[0].items, vec![Sel::Body { name: "Plate".into() }]);
|
||||
assert!(scenario::handle_at("dialog:Selection Filter").is_some());
|
||||
assert!(scenario::rect_of("dialog:row:Projection Link").is_some());
|
||||
|
||||
h.step(&json!({"click":{"handle":"dialog:Selection Filter"}})).unwrap();
|
||||
assert!(scenario::handle_at("dialog:Selection Filter:Geometry").is_some());
|
||||
h.step(&json!({"click":{"handle":"dialog:Selection Filter:Geometry"}})).unwrap();
|
||||
assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].accept, super::PROJECT_GEOMETRY);
|
||||
assert!(h.app.dialog.as_ref().unwrap().inputs[0].items.is_empty());
|
||||
h.step(&json!({"click":{"handle":"dialog:Selection Filter"}})).unwrap();
|
||||
h.step(&json!({"click":{"handle":"dialog:Selection Filter:Bodies"}})).unwrap();
|
||||
h.step(&json!({"click":{"handle":"dialog:Projection Link"}})).unwrap();
|
||||
assert!(matches!(h.app.dialog.as_ref().unwrap().kind, Kind::SketchProject { projection_link: false, .. }));
|
||||
|
||||
{
|
||||
let d = h.app.dialog.as_mut().unwrap();
|
||||
d.inputs[0].items = vec![Sel::Body { name: "Plate".into() }];
|
||||
}
|
||||
let d = h.app.dialog.as_ref().unwrap();
|
||||
assert_eq!(apply_commands(&h.app, d).unwrap(), vec![("sketch.project".into(), json!({"refs":[{"body":"Plate"}],"projection_link":false}))]);
|
||||
h.step(&json!({"click":{"handle":"dialog:ok"}})).unwrap();
|
||||
h.settle();
|
||||
assert!(h.app.dialog.is_none());
|
||||
let sketch = h.app.session.active_sketch.expect("Project leaves the sketch active");
|
||||
let state = h.app.session.world_state();
|
||||
let sketch = &state.sketch(sketch).unwrap().sketch;
|
||||
assert!(sketch.links.is_empty());
|
||||
assert!(!sketch.curves.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn apply_commits_once_keeps_values_and_waits_for_new_selection_ok_closes() {
|
||||
for command in ["sketch.offset", "sketch.mirror", "sketch.pattern.rectangular", "sketch.pattern.circular"] {
|
||||
|
||||
@@ -1704,6 +1704,19 @@ impl SolveApp {
|
||||
{
|
||||
self.last_command = Some((spec.id.to_string(), spec.label.to_string()));
|
||||
}
|
||||
if id == "sketch.project"
|
||||
&& self.preferences.project_options_dialog
|
||||
&& let Some(mut d) = dialogs::Dialog::for_command(self, id)
|
||||
{
|
||||
if let Some(sketch) = finished_sketch {
|
||||
d.take_sketch_profile(&self.session, sketch);
|
||||
}
|
||||
if d.wants_picks() && !self.session.selection.is_empty() {
|
||||
let _ = self.session.execute("select.clear", &json!({}));
|
||||
}
|
||||
self.dialog = Some(d);
|
||||
return;
|
||||
}
|
||||
if let Some(mut t) = tools::Tool::for_command(id) {
|
||||
let state = self.session.world_state();
|
||||
let sketch = self.session.active_sketch.and_then(|s| state.sketch(s)).map(|ss| &ss.sketch);
|
||||
|
||||
@@ -1224,6 +1224,8 @@ preference_settings! {
|
||||
suppress_sketch_snap: ModifierCombo = ModifierCombo::CTRL_ALT, PAGE_SKETCH;
|
||||
/// Temporary horizontal/vertical guides from hovered centres and edge midpoints.
|
||||
sketch_tracking_guides: bool = true, PAGE_SKETCH;
|
||||
/// Open Project's options before picking; off restores its previous direct-pick workflow.
|
||||
project_options_dialog: bool = true, PAGE_SKETCH;
|
||||
/// Whether Alt/Option also frees gizmo / canvas manipulator arrows (Primary always does).
|
||||
manipulator_free_alt: bool = true, PAGE_SKETCH;
|
||||
/// A sketch's icon in History and the browser takes the colour of its solve state, and its
|
||||
|
||||
@@ -11,6 +11,8 @@ pub(super) fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
if ui_kit::checkbox(ui, crate::i18n::tr_label("Project face edges into new sketches"), &mut auto).changed() {
|
||||
let _ = app.run("sketch.auto_project", json!({"value": auto}));
|
||||
}
|
||||
ui_kit::checkbox(ui, app.tr("prefs.project_options_dialog"), &mut app.preferences.project_options_dialog)
|
||||
.on_hover_text(app.tr("prefs.project_options_dialog_note"));
|
||||
ui_kit::checkbox(ui, crate::i18n::tr_label("Pressing a tool's shortcut again switches its mode"), &mut app.preferences.shortcut_cycles_modes)
|
||||
.on_hover_text(crate::i18n::tr_label(
|
||||
"Before the first point, pressing a sketch tool's shortcut again steps through its creation modes. Off: it starts the tool again.",
|
||||
|
||||
@@ -267,13 +267,14 @@ fn sketch_name(app: &SolveApp, sketch: u64) -> String {
|
||||
}
|
||||
|
||||
/// "Line 3" (its kind and number), with what kind of geometry it is when that matters.
|
||||
fn curve_label(sk: &solidcraft_engine::sketch::Sketch, id: &str) -> String {
|
||||
pub(crate) fn curve_label(sk: &solidcraft_engine::sketch::Sketch, id: &str) -> String {
|
||||
if let Some((i, c)) = sk.curves.iter().enumerate().find(|(_, c)| c.id == id) {
|
||||
let kind = curve_kind_name(&c.kind);
|
||||
let n = id_number(id).unwrap_or_else(|| sk.curves.iter().take(i + 1).filter(|x| curve_kind_name(&x.kind) == kind).count() as u64);
|
||||
let mut s = format!("{kind} {n}");
|
||||
if c.link.is_some() {
|
||||
s.push_str(" (projected)");
|
||||
if let Some(link) = &c.link {
|
||||
let kind = sk.links.iter().find(|l| &l.id == link).map(|l| l.kind);
|
||||
s.push_str(if kind == Some(solidcraft_engine::sketch::LinkKind::Intersect) { " (intersected)" } else { " (projected)" });
|
||||
} else if c.construction {
|
||||
s.push_str(" (construction)");
|
||||
}
|
||||
|
||||
@@ -615,3 +615,22 @@ fn a_small_body_on_a_large_one_is_not_picked_through() {
|
||||
assert!(point.x > 0.9, "at {distance} mm away the pick is behind the near face: {first:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_curve_from_intersect_is_labelled_intersected_and_one_from_project_projected() {
|
||||
use solidcraft_engine::sketch::LinkKind;
|
||||
let mut h = Harness::new();
|
||||
h.app.run("solid.box", json!({"length":40,"width":10,"height":10,"body_name":"Block"})).unwrap();
|
||||
let label = |h: &Harness, kind: LinkKind| {
|
||||
let sk = h.app.session.doc.sketch(h.app.session.active_sketch.unwrap()).unwrap();
|
||||
let c = sk.curves.iter().find(|c| c.link.as_deref().and_then(|l| sk.link(l)).is_some_and(|l| l.kind == kind)).unwrap();
|
||||
crate::select_other::curve_label(sk, &c.id)
|
||||
};
|
||||
h.app.run("sketch.create", json!({"plane":"XY","offset":5,"project_edges":false})).unwrap();
|
||||
h.app.run("sketch.intersect", json!({"refs":[{"body":"Block"}]})).unwrap();
|
||||
assert!(label(&h, LinkKind::Intersect).ends_with("(intersected)"));
|
||||
h.app.run("sketch.finish", json!({})).unwrap();
|
||||
h.app.run("sketch.create", json!({"plane":"XY","offset":20,"project_edges":false})).unwrap();
|
||||
h.app.run("sketch.project", json!({"refs":[{"body":"Block"}]})).unwrap();
|
||||
assert!(label(&h, LinkKind::Project).ends_with("(projected)"));
|
||||
}
|
||||
@@ -81,11 +81,28 @@ fn sketch_keys_outside_a_sketch_sketch_on_the_selected_plane_and_start_their_too
|
||||
assert!(h.app.session.active_sketch.is_some(), "{key}: no sketch opened");
|
||||
assert_eq!(h.app.session.world_state().sketches.len(), 1, "{key}");
|
||||
assert!(normal(&h).y.abs() > 0.999, "{key}: not on XZ: {:?}", normal(&h));
|
||||
assert_eq!(tool(&h), Some(cmd), "{key}");
|
||||
assert!(h.app.dialog.is_none(), "{key}: dialog left open");
|
||||
if cmd == "sketch.project" {
|
||||
assert!(h.app.preferences.project_options_dialog, "{key}: options are enabled by default");
|
||||
assert!(matches!(h.app.dialog.as_ref().map(|d| &d.kind), Some(crate::dialogs::Kind::SketchProject { .. })), "{key}");
|
||||
assert!(tool(&h).is_none(), "{key}: Project should open its options dialog");
|
||||
} else {
|
||||
assert_eq!(tool(&h), Some(cmd), "{key}");
|
||||
assert!(h.app.dialog.is_none(), "{key}: dialog left open");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn project_can_keep_its_previous_direct_pick_workflow() {
|
||||
let mut h = Harness::new();
|
||||
h.app.preferences.project_options_dialog = false;
|
||||
h.app.run("sketch.create", json!({"plane":"XY"})).unwrap();
|
||||
h.app.start("sketch.project");
|
||||
h.settle();
|
||||
assert!(h.app.dialog.is_none());
|
||||
assert_eq!(tool(&h), Some("sketch.project"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_sketch_key_sketches_on_the_selected_planar_face() {
|
||||
let mut h = Harness::new();
|
||||
|
||||
@@ -277,6 +277,15 @@ fn marks(app: &SolveApp, painter: &egui::Painter, proj: &Proj) {
|
||||
/// Commands that start with a step of their own: Canvas and Decal ask for the image first,
|
||||
/// Edit Canvas opens the canvas panel. False when the command should not go on.
|
||||
pub fn start_hook(app: &mut SolveApp, id: &str) -> bool {
|
||||
if id == "sketch.intersect"
|
||||
&& let Some(dialog) = crate::dialogs::Dialog::for_command(app, id)
|
||||
{
|
||||
if dialog.wants_picks() && !app.session.selection.is_empty() {
|
||||
let _ = app.session.execute("select.clear", &json!({}));
|
||||
}
|
||||
app.dialog = Some(dialog);
|
||||
return false;
|
||||
}
|
||||
if id == "sketch.edit_text"
|
||||
&& let Some(dialog) = crate::dialogs::Dialog::for_command(app, id)
|
||||
{
|
||||
|
||||
@@ -4,6 +4,8 @@ use solidcraft_ui_egui::scenario::Harness;
|
||||
|
||||
fn setup() -> (Harness, u64) {
|
||||
let mut h = Harness::new();
|
||||
// These cover the direct pick workflow; the options dialog is covered in dialogs_sketch_tests.
|
||||
h.app.preferences.project_options_dialog = false;
|
||||
let source = h.app.run("sketch.create", json!({"plane":"XY","offset":10})).unwrap()["sketch"].as_u64().unwrap();
|
||||
h.app.run("sketch.line", json!({"points":[[10,10],[30,10]],"infer":false})).unwrap();
|
||||
h.app.run("sketch.point", json!({"point":[20,20],"id":"p"})).unwrap();
|
||||
|
||||
Reference in new issue
Block a user