Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

9.2 KB
Raw Blame
//! STEP geometry (ISO 10303-42) as plain data: the curves and surfaces a file defines, exactly
//! as it defines them, in millimetres and radians. Nothing is approximated, bounded or turned
//! into another kind on the way in: a circle stays a circle with its placement, an unbounded
//! cylinder stays unbounded, and a B-spline keeps its own knots and form. Every curve and surface
//! keeps STEP's own parameterisation, so a 2D curve in a surface's parameter space means the same
//! thing here as in the file (SMLib's `SmSTEPSurface` evaluates the same parameterisation, with
//! angles in degrees where we use radians).
//!
//! Entities the file shares (one surface under many edges' pcurves) are shared here too, through
//! `Arc`, so reading is linear in the file however often an entity is referenced.

use std::sync::Arc;

/// A point or vector.
pub type P3 = [f64; 3];

/// AXIS2_PLACEMENT_3D (or _2D, with `axis` = +Z): an origin and two orthogonal unit directions.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Placement {
    pub origin: P3,
    /// Local Z.
    pub axis: P3,
    /// Local X (`ref_direction`, made orthogonal to `axis`).
    pub ref_direction: P3,
}

impl Placement {
    /// Local Y (`axis` × `ref_direction`).
    pub fn y(&self) -> P3 {
        cross(self.axis, self.ref_direction)
    }
    /// `origin + x·X + y·Y + z·Z`.
    pub fn at(&self, x: f64, y: f64, z: f64) -> P3 {
        let yy = self.y();
        add(self.origin, add(scale(self.ref_direction, x), add(scale(yy, y), scale(self.axis, z))))
    }
}

/// AXIS1_PLACEMENT: an origin and a unit direction.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Axis1 {
    pub origin: P3,
    pub direction: P3,
}

/// A STEP LOGICAL.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Logical {
    True,
    False,
    Unknown,
}

/// `b_spline_curve_form`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CurveForm {
    PolylineForm,
    CircularArc,
    EllipticArc,
    ParabolicArc,
    HyperbolicArc,
    Unspecified,
}

/// `b_spline_surface_form`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SurfaceForm {
    PlaneSurf,
    CylindricalSurf,
    ConicalSurf,
    SphericalSurf,
    ToroidalSurf,
    SurfOfRevolution,
    RuledSurf,
    GeneralisedCone,
    QuadricSurf,
    SurfOfLinearExtrusion,
    Unspecified,
}

/// `knot_type`. A curve given without knots (BEZIER_CURVE, UNIFORM_CURVE, QUASI_UNIFORM_CURVE)
/// has them worked out on reading, and keeps the matching type here.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum KnotSpec {
    UniformKnots,
    QuasiUniformKnots,
    PiecewiseBezierKnots,
    Unspecified,
}

/// A B-spline curve: distinct knots with their multiplicities, as STEP writes them.
#[derive(Clone, Debug, PartialEq)]
pub struct BSplineCurve {
    pub degree: usize,
    pub points: Vec<P3>,
    /// Present for a rational curve, one positive weight per point.
    pub weights: Option<Vec<f64>>,
    pub knots: Vec<f64>,
    pub multiplicities: Vec<usize>,
    pub form: CurveForm,
    pub closed: Logical,
    pub self_intersect: Logical,
    pub knot_spec: KnotSpec,
}

/// A B-spline surface; `points[i][j]` runs along u with `i`, along v with `j`.
#[derive(Clone, Debug, PartialEq)]
pub struct BSplineSurface {
    pub u_degree: usize,
    pub v_degree: usize,
    pub points: Vec<Vec<P3>>,
    pub weights: Option<Vec<Vec<f64>>>,
    pub u_knots: Vec<f64>,
    pub u_multiplicities: Vec<usize>,
    pub v_knots: Vec<f64>,
    pub v_multiplicities: Vec<usize>,
    pub form: SurfaceForm,
    pub u_closed: Logical,
    pub v_closed: Logical,
    pub self_intersect: Logical,
    pub knot_spec: KnotSpec,
}

/// One end of a TRIMMED_CURVE: a point on the basis curve, its parameter, or both.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Trim {
    Point(P3),
    Parameter(f64),
}

/// `trimming_preference`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TrimPreference {
    Cartesian,
    Parameter,
    Unspecified,
}

/// `preferred_surface_curve_representation`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PreferredRep {
    Curve3d,
    PcurveS1,
    PcurveS2,
}

/// Which SURFACE_CURVE subtype.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SurfaceCurveKind {
    Surface,
    Seam,
    Intersection,
    BoundedSurface,
}

/// PCURVE: a 2D curve in the parameter space of `surface`. Its coordinates are the surface's
/// own parameters (lengths in mm, angles in radians).
#[derive(Clone, Debug, PartialEq)]
pub struct Pcurve {
    pub surface: Arc<Surface>,
    /// A 2D curve: every point and placement has z = 0 and every placement axis is +Z.
    pub curve: Arc<Curve>,
}

/// An item of a SURFACE_CURVE's `associated_geometry`.
#[derive(Clone, Debug, PartialEq)]
pub enum Associated {
    Pcurve(Pcurve),
    Surface(Arc<Surface>),
}

/// CARTESIAN_TRANSFORMATION_OPERATOR_3D: `origin + scale·(x·X + y·Y + z·Z)`, where `X`, `Y`
/// and `Z` are the operator's unit axes (orthogonal, `Y` = ±`Z` × `X`: a negative sign mirrors).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Transform {
    pub origin: P3,
    pub x: P3,
    pub y: P3,
    pub z: P3,
    pub scale: f64,
}

impl Transform {
    /// The point `p` moved.
    pub fn point(&self, p: P3) -> P3 {
        add(self.origin, self.vector(p))
    }
    /// The vector `v` turned and scaled, not translated.
    pub fn vector(&self, v: P3) -> P3 {
        scale(add(scale(self.x, v[0]), add(scale(self.y, v[1]), scale(self.z, v[2]))), self.scale)
    }
    /// The direction `d` turned (its length kept).
    pub fn direction(&self, d: P3) -> P3 {
        add(scale(self.x, d[0]), add(scale(self.y, d[1]), scale(self.z, d[2])))
    }
    /// Whether the operator keeps handedness (no mirror).
    pub fn is_proper(&self) -> bool {
        dot(cross(self.x, self.y), self.z) > 0.0
    }
}

/// A STEP curve.
#[derive(Clone, Debug, PartialEq)]
pub enum Curve {
    /// `origin + t·magnitude·direction`.
    Line {
        origin: P3,
        direction: P3,
        magnitude: f64,
    },
    /// Parameter: the angle from `ref_direction`.
    Circle {
        position: Placement,
        radius: f64,
    },
    Ellipse {
        position: Placement,
        semi_axis_1: f64,
        semi_axis_2: f64,
    },
    /// `origin + a·cosh t·X + b·sinh t·Y`.
    Hyperbola {
        position: Placement,
        semi_axis: f64,
        semi_imag_axis: f64,
    },
    /// `origin + f·t²·X + 2f·t·Y`.
    Parabola {
        position: Placement,
        focal_dist: f64,
    },
    BSpline(Box<BSplineCurve>),
    /// Segment `i` (from 0) is the parameters `[i, i + 1]`.
    Polyline(Vec<P3>),
    Trimmed {
        basis: Arc<Curve>,
        trim_1: Vec<Trim>,
        trim_2: Vec<Trim>,
        sense: bool,
        preference: TrimPreference,
    },
    SurfaceCurve {
        kind: SurfaceCurveKind,
        curve_3d: Arc<Curve>,
        associated: Vec<Associated>,
        master: PreferredRep,
    },
    OffsetCurve3d {
        basis: Arc<Curve>,
        distance: f64,
        self_intersect: Logical,
        ref_direction: P3,
    },
    /// CURVE_REPLICA: the parent curve moved by `transform`, with the parent's parameter.
    Replica {
        parent: Arc<Curve>,
        transform: Transform,
    },
}

/// A STEP surface.
#[derive(Clone, Debug, PartialEq)]
pub enum Surface {
    /// `origin + u·X + v·Y`.
    Plane {
        position: Placement,
    },
    /// `origin + r·(cos u·X + sin u·Y) + v·Z`.
    Cylinder {
        position: Placement,
        radius: f64,
    },
    /// `origin + (r + v·tan a)·(cos u·X + sin u·Y) + v·Z`.
    Cone {
        position: Placement,
        radius: f64,
        semi_angle: f64,
    },
    /// `origin + r·cos v·(cos u·X + sin u·Y) + r·sin v·Z`.
    Sphere {
        position: Placement,
        radius: f64,
    },
    /// `origin + (R + r·cos v)·(cos u·X + sin u·Y) + r·sin v·Z`.
    Torus {
        position: Placement,
        major_radius: f64,
        minor_radius: f64,
    },
    /// A torus whose minor radius reaches the axis; `select_outer` keeps the outer part.
    DegenerateTorus {
        position: Placement,
        major_radius: f64,
        minor_radius: f64,
        select_outer: bool,
    },
    BSpline(Box<BSplineSurface>),
    /// The profile at `v` turned by the angle `u` about the axis.
    Revolution {
        profile: Arc<Curve>,
        axis: Axis1,
    },
    /// `profile(u) + v·magnitude·direction`.
    Extrusion {
        profile: Arc<Curve>,
        direction: P3,
        magnitude: f64,
    },
    Offset {
        basis: Arc<Surface>,
        distance: f64,
        self_intersect: Logical,
    },
    RectangularTrimmed {
        basis: Arc<Surface>,
        u1: f64,
        u2: f64,
        v1: f64,
        v2: f64,
        u_sense: bool,
        v_sense: bool,
    },
}

pub(crate) fn add(a: P3, b: P3) -> P3 {
    [a[0] + b[0], a[1] + b[1], a[2] + b[2]]
}
pub(crate) fn sub(a: P3, b: P3) -> P3 {
    [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
}
pub(crate) fn scale(a: P3, s: f64) -> P3 {
    [a[0] * s, a[1] * s, a[2] * s]
}
pub(crate) fn dot(a: P3, b: P3) -> f64 {
    a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
}
pub(crate) fn cross(a: P3, b: P3) -> P3 {
    [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
}
pub(crate) fn norm(a: P3) -> f64 {
    dot(a, a).sqrt()
}