Enum Kind 

pub enum Kind {
    Coincident,
    Concentric,
    Parallel,
    Perpendicular,
    Distance {
        value: Scalar,
    },
    Angle {
        value: Scalar,
    },
    Tangent,
    Path,
}

What a constraint asks of its two features.

Variants

Coincident

They touch: two points coincide, a point lies on a line or a plane, two lines are one, a line lies in a plane, two planes are one (facing either way).

Concentric

Two lines — axes, as a round edge or face has — are one.

Parallel

Lines and planes run parallel: two lines, two planes’ normals, a line along a plane.

Perpendicular

Lines and planes stand square: two lines, two planes, a line along a plane’s normal.

Distance

They are value apart: two points, a point and a line or a plane, or two parallel lines or planes, or a line parallel to a plane.

Fields

value: Scalar

Angle

The lines (or planes’ normals) meet at value degrees.

Fields

value: Scalar

Tangent

The second entity keeps touching the first, a face, flat or curved: a circle — a roller’s rim, a pin’s — keeps its radius off the face, its center on the face’s offset, a point stays on the face. A cam and its follower, a pin in a slot of any shape.

Path

The second entity — a point, a circle’s center — runs along the first, a curve: a path mate, a pin along a slot’s center line.

Implementations

impl Kind

pub fn label(&self) -> &'static str

pub fn feet(&self) -> &'static [&'static str]

The names of the parameters of the foot point on the first entity it is kept at, each a value of the state: the curve’s t, the face’s u and v. None for a kind that keeps no point on a curve or a face.

pub fn roles(&self) -> &'static [Role]

What an entity of a constraint of this kind can be, in the order its geometry is taken (see Kind::geometry): for one that touches or keeps a distance, a point before a line before a plane before a round face’s axis; for a concentric one, an axis; for one that turns, a direction.

A flat face is its plane before it is anything round: the cap of a revolved cylinder is a disc, a surface of revolution round the cylinder’s axis, and a part standing on it stands on the plane, not with the axis in it. Only a concentric mate wants the disc’s axis.

pub fn geometry( &self, k: usize, shape: &Shape, surface: impl FnOnce() -> GeopResult<Option<NurbSurface3D>>, curve: impl FnOnce() -> GeopResult<Option<NurbCurve3D>>, ) -> GeopResult<Option<Geometry>>

The geometry the kth entity of a constraint of this kind contributes, shape — as the first of its Kind::roles it fits — and surface and curve, the wall of a face and the run of an edge, asked of a tangent’s first and of a path’s first only: of a tangent constraint, the face first and then the circle or the point that touches it; of a path, the curve and then the point that runs along it.

pub fn needs(&self, k: usize) -> Option<&'static str>

What the kth entity of a constraint of this kind has to be, in words, where it is not what Kind::roles says: of a tangent and of a path, each entity something of its own.

pub fn fits(&self, a: &Geometry, b: &Geometry) -> GeopResult<()>

Checks that it can hold between a and b at all: a distance between two lines, say, but no angle at a point.

Trait Implementations

impl Clone for Kind

fn clone(&self) -> Kind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Kind

impl Debug for Kind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Kind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Kind

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Kind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Kind