Struct FaceFold 

pub struct FaceFold {
    pub face: u64,
    pub face_name: Option<String>,
    pub uv_a: [f64; 2],
    pub uv_b: [f64; 2],
    pub point: Vec3,
    pub uv_separation: f64,
    pub uv_band: f64,
    pub residual: f64,
    pub normal_angle: f64,
}

One confirmed place a face FOLDS THROUGH ITSELF in 3D: its own surface carries two DISTINCT trimmed parameter feet to ONE point in space.

This is the defect a FaceCrossing structurally cannot hold. A crossing is between two faces and is confirmed by a signed straddle of the OTHER carrier; with both triangles on ONE carrier every corner sits at distance zero from it, so that test is degenerate by construction and the pair was only ever counted. A fold is confirmed by a different question, asked in parameter space where it is exact: are the two feet DISTINCT, are both inside the face’s own trim, and do they land on the same 3D point?

Fields

face: u64

face_name: Option<String>

uv_a: [f64; 2]

The two parameter feet, each inside the face’s own trim.

uv_b: [f64; 2]

point: Vec3

Where they meet — the midpoint of the two surface images.

uv_separation: f64

Parameter distance between the feet, measured the SHORT way round every closed direction, so a seam is never mistaken for a separation.

uv_band: f64

The parameter distance at which two feet count as ONE: half a cell of the face’s own sample grid, which is built at the tessellation’s own resolution. Two seeds closer than this refine to the same foot — which is what a chord-error crossing on a sharply curved face produces — and a face that ends with one foot is rejected.

residual: f64

|S(uv_a) - S(uv_b)|: how coincident in 3D the two feet actually are. Bounded by the mesh’s own chord tolerance, and recorded so a reader can see the margin rather than trust the verdict.

normal_angle: f64

Angle between the two surface normals, in radians. A genuine fold crosses TRANSVERSALLY. A degenerate parameterization — a pole, a seam the period reduction did not fold away — also carries distinct uv to one point, but with ONE tangent plane; that is rejected here rather than reported as a fold.

Trait Implementations

impl Clone for FaceFold

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FaceFold

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

Formats the value using the given formatter.

impl Serialize for FaceFold

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

where __S: Serializer,

Serialize this value into the given Serde serializer.