indicatrix 0.9.0

A physically-based spectral gemstone renderer that turns GemCAD-style cutting instructions into rendered output.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Tier/block classification: which of crown, pavilion or girdle each tier
//! belongs to, plus the crown/pavilion side convention ([`tier_sides`]) shared
//! with the normal-vector construction in `candidates`.

use super::MeetTierInput;
use crate::geometry::plane::tier_is_crown_side;

/// Which block a tier belongs to.
///
/// Classified like [`solve_meet_points`](super::solve_meet_points)'s arrangement:
/// by the sign/magnitude of the tier's normal `y`-component, a pure function of
/// `angle_deg` and crown/pavilion side (same for every index instance of a tier).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Block {
    Crown,
    Pavilion,
    Girdle,
}

/// Classifies every tier's [`Block`] in one pass, per [`tier_sides`]'s sign rule.
#[must_use]
pub fn classify_blocks(tiers: &[MeetTierInput]) -> Vec<Block> {
    let sides = tier_sides(tiers);
    tiers
        .iter()
        .zip(&sides)
        .map(|(t, &crown)| {
            let theta = t.angle_deg.abs().to_radians();
            let y = if crown { theta.cos() } else { -theta.cos() };
            // Purpose: classify an exact `f64` schedule angle (a 90 degree tier
            // gives `|cos| ~ 6e-17`), so the threshold only has to absorb libm noise.
            // Deliberately tighter than `girdle::GIRDLE_NORMAL_Y_EPSILON` (1e-3, for
            // `f32` plane normals carrying normalize noise) and looser in kind than
            // the 85 degree girdle-tier pick in `names` (a naming heuristic, not a
            // geometric test).
            if y.abs() <= 1e-6 {
                Block::Girdle
            } else if y > 0.0 {
                Block::Crown
            } else {
                Block::Pavilion
            }
        })
        .collect()
}

/// Crown/pavilion side per tier (`true` = crown), from each tier's own angle sign
/// via [`tier_is_crown_side`] -- a sign-negative zero is the culet, a positive
/// zero the table; file order plays no part.
pub(super) fn tier_sides(tiers: &[MeetTierInput]) -> Vec<bool> {
    tiers
        .iter()
        .map(|tier| tier_is_crown_side(tier.angle_deg))
        .collect()
}

#[cfg(test)]
mod tests {
    use super::{super::MeetConstraint, *};

    #[test]
    fn classify_blocks_matches_angle_sign_and_girdle_threshold() {
        let tiers = vec![
            MeetTierInput {
                angle_deg: 45.0,
                indices: vec![],
                constraint: MeetConstraint::MeetExisting,
                names: vec![],
            },
            MeetTierInput {
                angle_deg: -45.0,
                indices: vec![],
                constraint: MeetConstraint::MeetExisting,
                names: vec![],
            },
            MeetTierInput {
                angle_deg: 90.0,
                indices: vec![],
                constraint: MeetConstraint::MeetExisting,
                names: vec![],
            },
            MeetTierInput {
                angle_deg: -90.0,
                indices: vec![],
                constraint: MeetConstraint::MeetExisting,
                names: vec![],
            },
        ];
        let blocks = classify_blocks(&tiers);
        assert_eq!(
            blocks,
            vec![Block::Crown, Block::Pavilion, Block::Girdle, Block::Girdle]
        );
    }
}