Enum ElevationLaw

#[non_exhaustive]
pub enum ElevationLaw {
    Polynomial {
        coefficients: Vec<Scalar>,
    },
    Piecewise {
        breaks: Vec<Scalar>,
        laws: Vec<ElevationLaw>,
    },
}

Height as a function of distance along the plan.

Mirrors CurvatureLaw in shape so the two halves of an alignment read the same way, but stays a separate type: a curvature law is a property of a planar curve and an elevation law is not, and sharing one enum would make a meaningless pairing representable.

Dirty imported data stays representable, as everywhere else in this crate. Mismatched piece lists report None rather than guessing.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Polynomial

z(d) = coefficients[0] + coefficients[1] * d + coefficients[2] * d^2 + ...

Degree 1 is a constant gradient, degree 2 the parabolic vertical curve used to join two grades. Those are the two vertical segment kinds that carry most alignment data, and both are exact here.

An empty coefficient list is the zero polynomial: height zero.

Fields

coefficients: Vec<Scalar>

Coefficients in ascending powers of plan distance.

Piecewise

Pieces laid end to end along plan distance, each with its own law.

breaks holds the INTERIOR seam positions measured from the start, so laws.len() == breaks.len() + 1 and piece i spans breaks[i - 1] .. breaks[i].

Each piece’s law is written in its OWN distance, restarting at zero at its seam, so moving a piece never rewrites its coefficients. This matches CurvatureLaw::Piecewise deliberately: a vertical profile is authored as a run of segments and the seams are observable data.

Fields

breaks: Vec<Scalar>

Interior seam positions in plan distance, ascending.

laws: Vec<ElevationLaw>

One law per piece; laws.len() == breaks.len() + 1.

Implementations

impl ElevationLaw

pub fn level(height: Scalar) -> Self

A constant height.

pub fn constant_grade(height: Scalar, grade: Scalar) -> Self

A constant gradient: z(d) = height + grade * d.

pub fn parabolic( height: Scalar, entry_grade: Scalar, exit_grade: Scalar, length: Scalar, ) -> Self

A parabolic vertical curve joining entry_grade to exit_grade over length.

The rate of change of grade is (exit - entry) / length, so z(d) = height + entry * d + (exit - entry) / (2 * length) * d^2. A non-positive length is storable; naming it is a validator’s job.

pub fn is_well_formed(&self) -> bool

Whether the piece lists agree and the seams ascend.

pub fn height_at(&self, distance: Scalar) -> Option<Scalar>

Height at distance along the plan.

Returns None when the law is malformed or the distance is not finite, rather than extrapolating off a piece that does not exist.

pub fn grade_at(&self, distance: Scalar) -> Option<Scalar>

Grade – dz/dd – at distance along the plan.

This is the slope the 3D tangent needs, and it is why the polynomial is differentiated exactly rather than differenced.

Trait Implementations

impl Clone for ElevationLaw

fn clone(&self) -> ElevationLaw

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ElevationLaw

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

Formats the value using the given formatter.

impl PartialEq for ElevationLaw

fn eq(&self, other: &ElevationLaw) -> 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 StructuralPartialEq for ElevationLaw