Struct PlaneFrame 

pub struct PlaneFrame {
    pub origin: [f64; 3],
    pub x_axis: [f64; 3],
    pub y_axis: [f64; 3],
    pub z_axis: [f64; 3],
}

An orthonormal placement frame for a sketch plane — origin + in-plane x/y axes + the z normal, all in world space (f64). A plane (u, v) coordinate maps to world origin + u·x + v·y (via to_world).

Mirrors the kernel’s feature_pipeline::Frame shape; kept local (and f64) so the sketch module stays self-contained and matches the solver’s double-precision coordinates. Later slices resolve this from the sketch’s plane reference (a DATUM/PLANE frame or a face frame); S0 uses the XY plane.

Fields

origin: [f64; 3]

x_axis: [f64; 3]

y_axis: [f64; 3]

z_axis: [f64; 3]

Implementations

impl PlaneFrame

pub fn xy() -> Self

The world XY plane (identity frame): u → +x, v → +y, normal +z.

pub fn xz() -> Self

The world XZ base plane (datum.rs normal (0, -1, 0)), resolved through the same worldUp convention the kernel uses (see from_normal).

pub fn yz() -> Self

The world YZ base plane (datum.rs normal (1, 0, 0)), resolved through the same worldUp convention the kernel uses (see from_normal).

pub fn from_normal(origin: [f64; 3], normal: [f64; 3]) -> Self

Derive an orthonormal frame from an origin + plane normal, a faithful port of feature_pipeline::Frame::from_origin_normal — the kernel’s SINGLE source of truth for how a plane reference becomes in-plane axes:

refUp = |n·(0,1,0)| > 0.9 ? (1,0,0) : (0,1,0)
x = norm(refUp × n);  y = norm(n × x);  z = n

A degenerate (zero / non-finite) normal — or a normal collinear with the picked refUp — returns the XY identity axes (at origin) rather than erroring, so callers always get a usable frame.

pub fn from_basis_json(basis: &Value) -> Self

Read a persisted persistentData.basis object ({origin, x, y, z}, each a [x, y, z] array) into a frame, mirroring the kernel’s persisted_basis_frame (features/sketch.rs). Missing keys default to the identity components, so a partial / absent basis still yields a usable XY-ish frame.

pub fn to_world(&self, u: f64, v: f64) -> [f64; 3]

Map a plane (u, v) coordinate to world [x, y, z].

pub fn to_uv(&self, world: [f64; 3]) -> (f64, f64)

Project a world point onto the plane’s (u, v) frame — the inverse of to_world. With orthonormal axes this is plain dot products against the offset from the origin (d = world − origin; u = d·x_axis, v = d·y_axis); a point off the plane projects orthogonally (its normal component is dropped). Mirrors the previous sketcher’s world→UV projection.

Trait Implementations

impl Clone for PlaneFrame

fn clone(&self) -> PlaneFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for PlaneFrame

impl Debug for PlaneFrame

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

Formats the value using the given formatter.

impl Default for PlaneFrame

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for PlaneFrame

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PlaneFrame