lib3mf-core 0.4.0

Parse and validate 3MF files for manufacturing workflows - production-ready with streaming parser and comprehensive validation
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use serde::{Deserialize, Serialize};

/// Units of measurement for the 3MF model.
///
/// Defines how vertex coordinates and dimensions are interpreted in real-world
/// measurements. The unit applies to all geometric coordinates in the model
/// (vertices, transformations, radii, etc.).
///
/// Per the 3MF specification, the default unit is Millimeter if not specified.
///
/// # Examples
///
/// ```
/// use lib3mf_core::model::Unit;
///
/// // Default is millimeter
/// let unit = Unit::default();
/// assert_eq!(unit, Unit::Millimeter);
///
/// // Convert between units
/// let inches = Unit::Inch.convert(1.0, Unit::Millimeter);
/// assert!((inches - 25.4).abs() < 1e-5);
///
/// // Get scale factor to meters
/// assert_eq!(Unit::Millimeter.scale_factor(), 0.001);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum Unit {
    /// Micrometers - 0.000001 meters (1 μm)
    Micron,
    /// Millimeters - 0.001 meters (1 mm) - Default per 3MF spec
    #[default]
    Millimeter,
    /// Centimeters - 0.01 meters (1 cm)
    Centimeter,
    /// Inches - 0.0254 meters (1 in)
    Inch,
    /// Feet - 0.3048 meters (1 ft)
    Foot,
    /// Meters - 1.0 meters (1 m)
    Meter,
}

impl Unit {
    /// Returns the scale factor to convert this unit to meters.
    ///
    /// # Examples
    ///
    /// ```
    /// use lib3mf_core::model::Unit;
    ///
    /// assert_eq!(Unit::Millimeter.scale_factor(), 0.001);
    /// assert_eq!(Unit::Meter.scale_factor(), 1.0);
    /// ```
    pub fn scale_factor(&self) -> f64 {
        match self {
            Unit::Micron => 1e-6,
            Unit::Millimeter => 0.001,
            Unit::Centimeter => 0.01,
            Unit::Inch => 0.0254,
            Unit::Foot => 0.3048,
            Unit::Meter => 1.0,
        }
    }

    /// Converts a value from this unit to another target unit.
    ///
    /// # Arguments
    ///
    /// * `value` - The value in this unit
    /// * `target` - The unit to convert to
    ///
    /// # Returns
    ///
    /// The value converted to the target unit.
    ///
    /// # Examples
    ///
    /// ```
    /// use lib3mf_core::model::Unit;
    ///
    /// // 1 inch = 25.4 mm
    /// let mm = Unit::Inch.convert(1.0, Unit::Millimeter);
    /// assert!((mm - 25.4).abs() < 1e-5);
    ///
    /// // 1000 mm = 1 meter
    /// let m = Unit::Millimeter.convert(1000.0, Unit::Meter);
    /// assert!((m - 1.0).abs() < 1e-5);
    /// ```
    pub fn convert(&self, value: f64, target: Unit) -> f64 {
        if *self == target {
            return value;
        }
        let meters = value * self.scale_factor();
        meters / target.scale_factor()
    }
}

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

    #[test]
    fn test_scale_factors() {
        assert!((Unit::Millimeter.scale_factor() - 0.001).abs() < 1e-10);
        assert!((Unit::Inch.scale_factor() - 0.0254).abs() < 1e-10);
    }

    #[test]
    fn test_conversion() {
        // 1 inch is 25.4 mm
        let val = Unit::Inch.convert(1.0, Unit::Millimeter);
        assert!((val - 25.4).abs() < 1e-5);

        // 1000 mm is 1 meter
        let val = Unit::Millimeter.convert(1000.0, Unit::Meter);
        assert!((val - 1.0).abs() < 1e-5);
    }
}