Files
solidcraft/crates/sketch/src/pattern.rs
T

564 lines
27 KiB
Rust

//! Stored parameters and stable entity ids for editing an existing sketch pattern.
use serde::{Deserialize, Serialize};
use solidcraft_geom::Vec2;
use crate::{ConstraintKind, Curve, CurveKind, Sketch, SketchError};
/// Placement relative to the original, along a pattern direction's oriented line.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PatternAlignment {
Left,
Center,
#[default]
Right,
}
impl PatternAlignment {
/// Slot zero is always the original. Center alternates sides to retain stable copy ids.
pub fn multiplier(self, index: usize, reversed: bool) -> f64 {
let value = match self {
Self::Left => -(index as f64),
Self::Right => index as f64,
Self::Center if index.is_multiple_of(2) => -((index / 2) as f64),
Self::Center => index.div_ceil(2) as f64,
};
if reversed { -value } else { value }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum SketchPatternKind {
Circular {
center: String,
count: usize,
angle: f64,
#[serde(default)]
alignment: PatternAlignment,
#[serde(default)]
reversed: bool,
},
Rectangular {
dir: Vec2,
#[serde(default)]
dir2: Option<Vec2>,
#[serde(default)]
direction: Option<String>,
#[serde(default)]
direction2: Option<String>,
count: usize,
spacing: f64,
count2: usize,
spacing2: f64,
#[serde(default)]
alignment: PatternAlignment,
#[serde(default)]
alignment2: PatternAlignment,
#[serde(default)]
reversed: bool,
#[serde(default)]
reversed2: bool,
},
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PatternInstance {
pub index: [usize; 2],
pub curves: Vec<String>,
/// Seed point id and instance point id, in the order used to create the copy.
pub points: Vec<(String, String)>,
pub constraints: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SketchPattern {
pub id: String,
pub entities: Vec<String>,
pub kind: SketchPatternKind,
/// Authored circular Quantity expression; absent for legacy and fixed-count patterns.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub count_expression: Option<String>,
pub instances: Vec<PatternInstance>,
#[serde(default, skip_serializing_if = "std::collections::BTreeMap::is_empty")]
pub expressions: std::collections::BTreeMap<String, String>,
}
impl SketchPattern {
/// Resolve an evaluated circular Quantity with the dialog's whole-number tolerance.
pub fn circular_quantity(value: f64) -> Result<usize, SketchError> {
let count = value.round();
if !value.is_finite() || !(1.0..=500.0).contains(&value) || count < 2.0 || (value - count).abs() > 1e-9 {
return Err(SketchError::Invalid("circular pattern Quantity must be a whole number from 2 to 500".into()));
}
Ok(count as usize)
}
pub fn contains(&self, entity: &str) -> bool {
self.entities.iter().any(|id| id == entity)
|| self
.instances
.iter()
.any(|instance| instance.curves.iter().any(|id| id == entity) || instance.points.iter().any(|(_, id)| id == entity))
|| matches!(&self.kind, SketchPatternKind::Circular { center, .. } if center == entity)
|| matches!(&self.kind, SketchPatternKind::Rectangular { direction, direction2, .. }
if direction.as_deref() == Some(entity) || direction2.as_deref() == Some(entity))
}
}
impl Sketch {
/// Rebuild a circular Quantity while retaining surviving copy ids.
pub fn resize_circular_pattern(&mut self, id: &str, count: usize) -> Result<(), SketchError> {
if !(2..=500).contains(&count) {
return Err(SketchError::Invalid("circular pattern Quantity must be 2…500".into()));
}
self.validate_patterns()?;
let index = self.patterns.iter().position(|p| p.id == id).ok_or_else(|| SketchError::Invalid("missing sketch pattern".into()))?;
let mut kind = self.patterns.get(index).ok_or_else(|| SketchError::Invalid("missing sketch pattern".into()))?.kind.clone();
let SketchPatternKind::Circular { count: previous, .. } = &mut kind else {
return Err(SketchError::Invalid("Quantity expression requires a circular pattern".into()));
};
if *previous == count {
return Ok(());
}
*previous = count;
self.update_pattern(index, kind)
}
/// Rebuild a pattern after its driving expressions change, retaining surviving copy ids.
pub fn update_pattern(&mut self, index: usize, kind: SketchPatternKind) -> Result<(), SketchError> {
let old = self.patterns.get(index).cloned().ok_or_else(|| SketchError::Invalid("missing sketch pattern".into()))?;
let check_count = |n: usize| {
if !(1..=500).contains(&n) { Err(SketchError::Invalid("pattern count must be a positive integer from 1 to 500".into())) } else { Ok(()) }
};
match &kind {
SketchPatternKind::Circular { count, angle, .. } => {
check_count(*count)?;
if !angle.is_finite() || angle.abs() <= 1e-9 || angle.abs() > 360.0 {
return Err(SketchError::Invalid("pattern angle must be nonzero and at most 360 degrees".into()));
}
}
SketchPatternKind::Rectangular { count, count2, spacing, spacing2, .. } => {
check_count(*count)?;
check_count(*count2)?;
if count.checked_mul(*count2).is_none_or(|n| n > 500) {
return Err(SketchError::Invalid("pattern counts must make at most 500 instances total".into()));
}
if ![spacing, spacing2].iter().all(|v| v.is_finite() && v.abs() <= crate::MAX_COORD) {
return Err(SketchError::Invalid("pattern spacing must be finite and in range".into()));
}
}
}
self.patterns.remove(index);
let entity_ids = old.entities.clone();
let (center, slots) = match &kind {
SketchPatternKind::Circular { center, count, angle, alignment, reversed } => {
let center = self.resolve_point(center).ok_or_else(|| SketchError::Invalid("missing pattern center".into()))?;
let full = (angle.abs() - 360.0).abs() < 1e-9;
let step = angle / if full { *count as f64 } else { (count.max(&2) - 1) as f64 };
(
Some(center),
(1..*count).map(|i| ([i, 0], (step * alignment.multiplier(i, *reversed)).to_radians(), Vec2::ZERO)).collect::<Vec<_>>(),
)
}
SketchPatternKind::Rectangular { count, count2, .. } => {
(None, (0..*count).flat_map(|i| (0..*count2).filter_map(move |j| (i != 0 || j != 0).then_some(([i, j], 0.0, Vec2::ZERO)))).collect())
}
};
let center_id = center.and_then(|i| self.points.get(i)).map(|p| p.id.clone());
let mut existing = old.instances.clone();
// Remove retired instances first: all following indices are resolved by stable id.
for instance in existing.iter().filter(|instance| !slots.iter().any(|(index, _, _)| *index == instance.index)) {
let curves: Vec<_> = instance.curves.iter().filter_map(|id| self.curve_index(id)).collect();
self.constraints.retain(|c| !instance.constraints.contains(&c.id));
self.remove_curves(&curves);
let points: Vec<_> = instance.points.iter().filter_map(|(_, id)| self.resolve_point(id)).collect();
self.remove_points(&points);
}
if let SketchPatternKind::Rectangular { direction, direction2, .. } = &kind {
for id in direction.iter().chain(direction2) {
if self.curve_index(id).is_none() {
return Err(SketchError::Invalid("the direction belongs to an instance removed by this edit".into()));
}
}
}
let mut instances = Vec::new();
let center = center_id.as_ref().and_then(|id| self.resolve_point(id));
if center_id.is_some() && center.is_none() {
return Err(SketchError::Invalid("the center belongs to an instance removed by this edit".into()));
}
for (index, angle, offset) in slots {
let (base_offset, directions) = linear_displacement(self, &kind, index, offset);
let c = center.and_then(|i| self.point(i)).unwrap_or(Vec2::ZERO);
let mut displacement = base_offset;
for (line, distance) in directions.into_iter().flatten() {
if let Some(crate::Shape::Line { a, b }) = self.shape(line)
&& let Some(u) = (b - a).normalized()
{
displacement += u * distance.x + u.perp() * distance.y;
}
}
let transform = |p| rotate(c, angle)(p) + displacement;
let instance = if let Some(i) = existing.iter().position(|instance| instance.index == index) {
let instance = existing.remove(i);
for cid in &instance.constraints {
if let Some(constraint) = self.constraints.iter_mut().find(|constraint| constraint.id == *cid)
&& let ConstraintKind::PatternPoint { center: slot, angle: a, offset: off, directions: dirs, .. } = &mut constraint.kind
{
*slot = center;
*a = angle;
*off = base_offset;
*dirs = directions;
}
}
for (seed, copy) in &instance.points {
let pos =
self.resolve_point(seed).and_then(|i| self.point(i)).ok_or_else(|| SketchError::Invalid("missing seed point".into()))?;
if let Some(point) = self.resolve_point(copy).and_then(|i| self.points.get_mut(i)) {
let at = transform(pos);
if !crate::model::in_range(at) {
return Err(SketchError::Invalid("pattern point is out of range".into()));
}
point.pos = at;
}
}
instance
} else {
let cs: Vec<_> = entity_ids.iter().filter_map(|id| self.curve_index(id)).collect();
let ps: Vec<_> = entity_ids.iter().filter(|id| self.curve_index(id).is_none()).filter_map(|id| self.resolve_point(id)).collect();
let (made, map) = copy_through(self, &cs, &ps, &transform)?;
let mut cons = Vec::new();
for (p, q) in &map {
cons.push(
self.add_constraint(ConstraintKind::PatternPoint { p: *p, q: *q, center, angle, offset: base_offset, directions }, None)?,
);
}
for (a, b) in cs.iter().zip(&made) {
if matches!(self.curves.get(*a).map(|c| &c.kind), Some(CurveKind::Circle { .. } | CurveKind::Ellipse { .. })) {
cons.push(self.add_constraint(ConstraintKind::PatternRadius { a: *a, b: *b }, None)?);
}
}
PatternInstance {
index,
curves: made.iter().filter_map(|i| self.curves.get(*i).map(|c| c.id.clone())).collect(),
points: map.iter().filter_map(|(p, q)| Some((self.points.get(*p)?.id.clone(), self.points.get(*q)?.id.clone()))).collect(),
constraints: cons,
}
};
instances.push(instance);
}
self.patterns.insert(index.min(self.patterns.len()), SketchPattern { kind, instances, ..old });
self.follow_pattern_seeds();
Ok(())
}
/// Start an explicit Move/Scale of seed geometry with its copies already transformed.
/// Interactive drags instead leave the ordinary relations to the held-point solver,
/// which also supports dragging an instance back through its seed.
pub fn follow_pattern_seeds(&mut self) {
let constraint_indices: std::collections::BTreeMap<_, _> = self.constraints.iter().enumerate().map(|(i, c)| (c.id.as_str(), i)).collect();
for pattern in &self.patterns {
for instance in &pattern.instances {
for cid in &instance.constraints {
let Some(kind) = constraint_indices.get(cid.as_str()).and_then(|i| self.constraints.get(*i)).map(|c| c.kind.clone()) else {
continue;
};
match kind {
crate::ConstraintKind::PatternPoint { p, q, center, angle, mut offset, directions } => {
for (l, distance) in directions.into_iter().flatten() {
if let Some(crate::Shape::Line { a, b }) = self.shape(l)
&& let Some(u) = (b - a).normalized()
{
offset += u * distance.x + u.perp() * distance.y;
}
}
let Some(seed) = self.point(p) else { continue };
let c = center.and_then(|c| self.point(c)).unwrap_or(Vec2::ZERO);
let d = seed - c;
let (sin, cos) = angle.sin_cos();
if let Some(copy) = self.points.get_mut(q) {
copy.pos = c + Vec2::new(d.x * cos - d.y * sin, d.x * sin + d.y * cos) + offset;
}
}
crate::ConstraintKind::PatternRadius { a, b } => {
let r = match self.curves.get(a).map(|c| &c.kind) {
Some(CurveKind::Circle { r, .. } | CurveKind::Ellipse { r, .. }) => Some(*r),
_ => None,
};
if let (Some(r), Some(CurveKind::Circle { r: copy, .. } | CurveKind::Ellipse { r: copy, .. })) =
(r, self.curves.get_mut(b).map(|c| &mut c.kind))
{
*copy = r;
}
}
_ => {}
}
}
}
}
self.refresh_pattern_shapes();
}
/// Deleting a seed, instance or relation breaks that pattern's association. Remaining
/// geometry stays in the sketch, without stale metadata that could resurrect a deletion.
pub fn prune_patterns(&mut self) {
if self.patterns.is_empty() {
return;
}
let curves: std::collections::BTreeSet<_> = self.curves.iter().map(|c| c.id.as_str()).collect();
let points: std::collections::BTreeSet<_> = self.points.iter().map(|p| p.id.as_str()).collect();
let constraint_ids: std::collections::BTreeSet<_> = self.constraints.iter().map(|c| c.id.as_str()).collect();
let retired: Vec<_> = self
.patterns
.iter()
.filter(|pattern| {
pattern.entities.iter().any(|id| !curves.contains(id.as_str()) && !points.contains(id.as_str()))
|| matches!(&pattern.kind, SketchPatternKind::Circular { center, .. } if !points.contains(center.as_str()))
|| matches!(&pattern.kind, SketchPatternKind::Rectangular { direction, direction2, .. }
if direction.iter().chain(direction2).any(|id| !curves.contains(id.as_str())))
|| pattern.instances.iter().any(|instance| {
instance.curves.iter().any(|id| !curves.contains(id.as_str()))
|| instance.points.iter().any(|(p, q)| !points.contains(p.as_str()) || !points.contains(q.as_str()))
|| instance.constraints.iter().any(|id| !constraint_ids.contains(id.as_str()))
})
})
.map(|pattern| pattern.id.clone())
.collect();
let constraints: std::collections::BTreeSet<_> =
self.patterns.iter().filter(|p| retired.contains(&p.id)).flat_map(|p| &p.instances).flat_map(|i| i.constraints.iter().cloned()).collect();
self.patterns.retain(|p| !retired.contains(&p.id));
self.constraints.retain(|c| !constraints.contains(&c.id));
}
/// Conic rho is an authored shape parameter rather than a solver unknown. Like its
/// defining points, the copies follow the seed's shape when that parameter is edited.
pub(crate) fn refresh_pattern_shapes(&mut self) {
if !self.curves.iter().any(|c| matches!(c.kind, CurveKind::Conic { .. } | CurveKind::Arc { .. })) {
return;
}
for pattern in &self.patterns {
let sources: Vec<_> = pattern.entities.iter().filter_map(|id| self.curve_index(id)).collect();
for instance in &pattern.instances {
for (seed, copy) in sources.iter().zip(&instance.curves) {
if let Some(CurveKind::Conic { rho, .. }) = self.curves.get(*seed).map(|c| &c.kind)
&& let Some(copy) = self.curve_index(copy)
{
let rho = *rho;
if let Some(CurveKind::Conic { rho: slot, .. }) = self.curves.get_mut(copy).map(|c| &mut c.kind) {
*slot = rho;
}
}
let Some(source) = self.curves.get(*seed).cloned() else { continue };
if let CurveKind::Arc { c, a, b } = source.kind {
let mapped = |p: usize| {
self.points
.get(p)
.and_then(|p| instance.points.iter().find(|(id, _)| *id == p.id))
.and_then(|(_, id)| self.point_index(id))
};
if let (Some(c), Some(a), Some(b), Some(copy)) = (mapped(c), mapped(a), mapped(b), self.curve_index(copy))
&& let Some(curve) = self.curves.get_mut(copy)
{
curve.kind = CurveKind::Arc { c, a, b };
curve.reversed = source.reversed;
}
}
}
}
}
}
pub fn validate_patterns(&self) -> Result<(), SketchError> {
if self.patterns.len() > crate::MAX_CONSTRAINTS {
return Err(SketchError::TooLarge);
}
let mut ids = std::collections::BTreeSet::new();
for pattern in &self.patterns {
if pattern.expressions.len() > 5
|| pattern.expressions.iter().any(|(key, expression)| {
!matches!(key.as_str(), "count" | "count2" | "spacing" | "spacing2" | "angle")
|| expression.trim().is_empty()
|| expression.len() > 4096
})
{
return Err(SketchError::Invalid("invalid sketch pattern expression".into()));
}
if pattern.count_expression.as_ref().is_some_and(|e| e.trim().is_empty() || e.len() > 4096)
|| (pattern.count_expression.is_some() && !matches!(pattern.kind, SketchPatternKind::Circular { .. }))
{
return Err(SketchError::Invalid("invalid circular pattern Quantity expression".into()));
}
if pattern.id.is_empty()
|| pattern.id.len() > 512
|| !ids.insert(&pattern.id)
|| pattern.entities.is_empty()
|| pattern.entities.len() > crate::MAX_CURVES + crate::MAX_POINTS
|| pattern.instances.len() >= 500
{
return Err(SketchError::Invalid("invalid sketch pattern".into()));
}
let valid_count = |n| (1..=500).contains(&n);
let finite = |v: f64| v.is_finite() && v.abs() <= crate::MAX_COORD;
let valid = match &pattern.kind {
SketchPatternKind::Circular { count, angle, center, .. } => {
valid_count(*count) && angle.is_finite() && angle.abs() > 1e-9 && angle.abs() <= 360.0 && self.resolve_point(center).is_some()
}
SketchPatternKind::Rectangular { count, count2, spacing, spacing2, dir, dir2, direction, direction2, .. } => {
valid_count(*count)
&& valid_count(*count2)
&& count.checked_mul(*count2).is_some_and(|n| n <= 500)
&& finite(*spacing)
&& finite(*spacing2)
&& finite(dir.x)
&& finite(dir.y)
&& (dir.len() - 1.0).abs() < 1e-6
&& dir2.is_none_or(|d| finite(d.x) && finite(d.y) && (d.len() - 1.0).abs() < 1e-6)
&& direction.iter().chain(direction2).all(|id| {
self.curve_index(id).is_some_and(|l| matches!(self.curves.get(l).map(|c| &c.kind), Some(CurveKind::Line { .. })))
})
}
};
if !valid {
return Err(SketchError::Invalid("invalid sketch pattern settings".into()));
}
let (n1, n2) = match pattern.kind {
SketchPatternKind::Circular { count, .. } => (count, 1),
SketchPatternKind::Rectangular { count, count2, .. } => (count, count2),
};
if pattern.instances.len() != n1 * n2 - 1 {
return Err(SketchError::Invalid("incomplete sketch pattern".into()));
}
let mut slots = std::collections::BTreeSet::new();
for instance in &pattern.instances {
let [i, j] = instance.index;
let valid_id = |id: &String| !id.is_empty() && id.len() <= 512;
if i >= n1
|| j >= n2
|| (i == 0 && j == 0)
|| !slots.insert(instance.index)
|| instance.points.len() > crate::MAX_POINTS
|| instance.curves.len() > crate::MAX_CURVES
|| instance.constraints.len() > crate::MAX_CONSTRAINTS
|| instance.curves.iter().any(|id| !valid_id(id) || self.curve_index(id).is_none())
|| instance
.points
.iter()
.any(|(p, q)| !valid_id(p) || !valid_id(q) || self.point_index(p).is_none() || self.point_index(q).is_none())
|| instance.constraints.iter().any(|id| {
!valid_id(id)
|| !self.constraints.iter().any(|c| {
c.id == *id
&& matches!(c.kind, crate::ConstraintKind::PatternPoint { .. } | crate::ConstraintKind::PatternRadius { .. })
})
})
{
return Err(SketchError::Invalid("invalid sketch pattern instance".into()));
}
}
}
for constraint in &self.constraints {
if matches!(constraint.kind, crate::ConstraintKind::PatternPoint { .. } | crate::ConstraintKind::PatternRadius { .. }) {
self.validate(&constraint.kind)?;
}
}
Ok(())
}
}
/// Keep sampled vector directions compatible with older designs, while picked lines are
/// solver references. The default second direction follows the first line's perpendicular.
fn linear_displacement(sk: &Sketch, kind: &SketchPatternKind, [i, j]: [usize; 2], fallback: Vec2) -> (Vec2, [Option<(usize, Vec2)>; 2]) {
let SketchPatternKind::Rectangular { dir, dir2, direction, direction2, spacing, spacing2, alignment, alignment2, reversed, reversed2, .. } = kind
else {
return (fallback, [None; 2]);
};
let mut offset = Vec2::ZERO;
let mut directions = [None; 2];
let d1 = *spacing * alignment.multiplier(i, *reversed);
let d2 = *spacing2 * alignment2.multiplier(j, *reversed2);
if let Some(l) = direction.as_ref().and_then(|id| sk.curve_index(id)) {
directions[0] = Some((l, Vec2::new(d1, if dir2.is_none() && direction2.is_none() { d2 } else { 0.0 })));
} else {
offset += *dir * d1;
if dir2.is_none() && direction2.is_none() {
offset += dir.perp() * d2;
}
}
if let Some(l) = direction2.as_ref().and_then(|id| sk.curve_index(id)) {
directions[1] = Some((l, Vec2::new(d2, 0.0)));
} else if let Some(dir2) = dir2 {
offset += *dir2 * d2;
}
(offset, directions)
}
fn involved_points(sk: &Sketch, cs: &[usize], ps: &[usize]) -> Vec<usize> {
let mut v: Vec<usize> = Vec::new();
for c in cs {
if let Some(k) = sk.curves.get(*c).map(|c| &c.kind) {
v.extend(k.point_ids());
}
}
v.extend(ps);
let mut out = Vec::new();
for q in v {
if !out.contains(&q) {
out.push(q);
}
}
out
}
/// Copy seed curves and their points, returning curves and the original-to-copy point map.
fn copy_through(sk: &mut Sketch, cs: &[usize], ps: &[usize], f: &dyn Fn(Vec2) -> Vec2) -> Result<(Vec<usize>, Vec<(usize, usize)>), SketchError> {
if sk.curves.len().saturating_add(cs.len()) > crate::MAX_CURVES {
return Err(crate::SketchError::TooLarge);
}
let pts = involved_points(sk, cs, ps);
let mut map: Vec<(usize, usize)> = Vec::new();
for q in &pts {
let pos = sk.point(*q).unwrap_or_default();
let n = sk.add_point(f(pos), None)?;
map.push((*q, n));
}
let m = |q: usize| map.iter().find(|x| x.0 == q).map(|x| x.1).unwrap_or(q);
let mut made = Vec::new();
for c in cs {
let Some(cu) = sk.curves.get(*c).cloned() else { continue };
let mut kind = cu.kind.clone();
kind.map_points(&m);
let prefix = match &kind {
CurveKind::Ellipse { .. } => "e",
CurveKind::Spline { .. } => "s",
CurveKind::Conic { .. } => "k",
CurveKind::Line { .. } => "l",
CurveKind::Circle { .. } => "c",
CurveKind::Arc { .. } => "a",
};
let id = sk.fresh(prefix)?;
// Copies retain the seed line's extent.
let infinite = cu.infinite && matches!(kind, CurveKind::Line { .. });
sk.curves.push(Curve {
id,
kind,
construction: cu.construction,
reversed: cu.reversed,
link: None,
centerline: false,
fixed: false,
infinite,
});
made.push(sk.curves.len() - 1);
}
Ok((made, map))
}
fn rotate(c: Vec2, ang: f64) -> impl Fn(Vec2) -> Vec2 {
move |q: Vec2| {
let d = q - c;
let (s, co) = ang.sin_cos();
c + Vec2::new(d.x * co - d.y * s, d.x * s + d.y * co)
}
}