Struct SketchData 

pub struct SketchData {
    pub points: Vec<SketchPoint>,
    pub entities: Vec<SketchEntity>,
    pub constraints: Vec<SketchConstraint>,
    pub next_id: u32,
}

A 2D sketch: points, entities, and the constraints between them.

Fields

points: Vec<SketchPoint>

entities: Vec<SketchEntity>

constraints: Vec<SketchConstraint>

next_id: u32

Next unallocated SketchId.

Implementations

impl SketchData

pub fn point(&self, id: u32) -> Option<&SketchPoint>

pub fn point_mut(&mut self, id: u32) -> Option<&mut SketchPoint>

pub fn point_pos(&self, id: u32) -> Option<DVec2>

pub fn entity(&self, id: u32) -> Option<&SketchEntity>

pub fn entity_mut(&mut self, id: u32) -> Option<&mut SketchEntity>

pub fn set_construction(&mut self, id: u32, construction: bool) -> bool

Mark an entity as construction (or geometry again). Returns whether the entity was found.

pub fn add_point(&mut self, pos: DVec2) -> u32

pub fn add_line(&mut self, p0: u32, p1: u32) -> u32

Add a line between two existing points.

pub fn add_circle(&mut self, center: DVec2, radius: f64) -> u32

pub fn add_circle_with_center(&mut self, center: u32, radius: f64) -> u32

Add a circle about an existing center point.

pub fn add_arc(&mut self, center: u32, start: u32, end: u32) -> u32

Add a counter-clockwise arc through existing points.

pub fn add_rect(&mut self, corner_a: DVec2, corner_b: DVec2) -> [u32; 4]

Add an axis-aligned rectangle as 4 points + 4 lines with horizontal/vertical constraints (the standard sketcher decomposition).

pub fn delete_entity(&mut self, id: u32)

Delete an entity, cascading to constraints that reference it and to points no longer used by any entity.

pub fn delete_constraint(&mut self, index: usize)

pub fn delete_point(&mut self, id: u32)

Delete a point, cascading to entities that use it (as endpoint or center) and to constraints that reference it — the entity cascade in turn prunes any points and constraints it orphans.

pub fn connected_components(&self) -> Vec<Vec<u32>>

Group entities into maximally connected shapes.

Two entities belong to the same component when they share a point or their points are pinned together by a SketchConstraint::Coincident — the same reachability profile_loops chains through. Value constraints between shapes (Distance, Parallel, …) do not merge them. Components are returned in first-appearance order; each lists its entity ids in sketch order.

pub fn entity_subset(&self, entity_ids: &[u32]) -> SketchData

Clone a profile-extraction view restricted to entity_ids: entities are filtered (sketch order kept); points, constraints and next_id are copied verbatim — unused ones are inert for profile_loops. Not a real partition; see Self::split_off_entities for that.

pub fn geometric_components(&self, arc_segments: usize) -> Vec<Vec<u32>>

Group entities into geometrically independent shapes: the connected components, merged (transitively) whenever their closed profile loops interact — one nested inside the other (it renders as a hole) or boundaries properly crossing (the profile is their union) — so extruding one shape never tears a hole off its outer. Components without closed loops (open chains) never merge. Groups are returned in first-appearance order, each listing its entity ids. Construction entities stay in their component’s group (they travel with the shape they’re attached to) but contribute no loops, so they never cause a merge on their own.

pub fn split_off_entities(&mut self, entity_ids: &[u32]) -> SketchData

Move the given entities — with their points and every constraint fully contained in the moved set — out of this sketch into a new one.

Intended for whole components from [connected_components], where the halves share no points. Constraints referencing both halves (e.g. a Distance between two shapes) are dropped: they can live in neither. next_id is carried over so ids stay unique across both halves.

impl SketchData

pub fn nearest_intersection( &self, cursor: DVec2, tolerance: f64, ) -> Option<SketchIntersection>

The supported-pair intersection nearest cursor, within tolerance.

Supported pairs: line×line, line×circle, line×arc — construction entities included. O(pairs); sketches are small.

pub fn split_at( &mut self, a: u32, b: u32, pos: DVec2, tolerance: f64, ) -> Result<Vec<u32>, &'static str>

Split entities a and b at their intersection nearest pos.

Exactly one shared point is created at the split, so the fragments stay joined. First fragments keep the original entity ids (constraint, selection and hover references stay valid); new fragments get fresh ids and inherit construction. A fragment shorter than tolerance is not created: that entity is left whole, while the other may still split. A circle needs the line to cross it twice (a secant); it becomes two arcs — one boundary per crossing — while the line still splits only at the crossing nearest pos. Constraints referencing a split entity are retargeted: direction/radius constraints are duplicated onto both fragments; Tangent/PointOnCurve move to the fragment nearest their referenced geometry.

Returns the newly created entity ids; the sketch is untouched on Err.

Trait Implementations

impl Clone for SketchData

fn clone(&self) -> SketchData

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SketchData

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for SketchData

fn default() -> SketchData

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SketchData

fn deserialize<__D>( __deserializer: __D, ) -> Result<SketchData, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SketchData

fn eq(&self, other: &SketchData) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SketchData

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SketchData