Skip to main content

cadkit_core/
units.rs

1//! Length-unit helpers: conversion to meters and DWG/DXF `$INSUNITS` codes.
2
3use crate::model::{LengthUnit, Units};
4
5impl LengthUnit {
6    /// Size of one unit in meters; `None` for [`LengthUnit::Unitless`] and [`LengthUnit::Custom`].
7    pub fn meters(self) -> Option<f64> {
8        Some(match self {
9            Self::Unitless | Self::Custom => return None,
10            Self::Inch => 0.0254,
11            Self::Foot => 0.3048,
12            Self::Mile => 1609.344,
13            Self::Millimeter => 0.001,
14            Self::Centimeter => 0.01,
15            Self::Meter => 1.0,
16            Self::Kilometer => 1000.0,
17            Self::Microinch => 2.54e-8,
18            Self::Mil => 2.54e-5,
19            Self::Yard => 0.9144,
20            Self::Angstrom => 1e-10,
21            Self::Nanometer => 1e-9,
22            Self::Micrometer => 1e-6,
23            Self::Decimeter => 0.1,
24            Self::Decameter => 10.0,
25            Self::Hectometer => 100.0,
26            Self::Gigameter => 1e9,
27            Self::AstronomicalUnit => 149_597_870_700.0,
28            Self::LightYear => 9_460_730_472_580_800.0,
29            Self::Parsec => 3.085_677_581_491_367e16,
30            Self::UsSurveyFoot => 1200.0 / 3937.0,
31        })
32    }
33
34    /// Maps a DWG/DXF `$INSUNITS` value to a unit. Unknown codes give [`LengthUnit::Unitless`].
35    pub fn from_insunits(code: i32) -> Self {
36        match code {
37            1 => Self::Inch,
38            2 => Self::Foot,
39            3 => Self::Mile,
40            4 => Self::Millimeter,
41            5 => Self::Centimeter,
42            6 => Self::Meter,
43            7 => Self::Kilometer,
44            8 => Self::Microinch,
45            9 => Self::Mil,
46            10 => Self::Yard,
47            11 => Self::Angstrom,
48            12 => Self::Nanometer,
49            13 => Self::Micrometer,
50            14 => Self::Decimeter,
51            15 => Self::Decameter,
52            16 => Self::Hectometer,
53            17 => Self::Gigameter,
54            18 => Self::AstronomicalUnit,
55            19 => Self::LightYear,
56            20 => Self::Parsec,
57            21 => Self::UsSurveyFoot,
58            _ => Self::Unitless,
59        }
60    }
61
62    /// The `$INSUNITS` code of this unit (0 for unitless and custom units).
63    pub fn to_insunits(self) -> i32 {
64        match self {
65            Self::Unitless | Self::Custom => 0,
66            Self::Inch => 1,
67            Self::Foot => 2,
68            Self::Mile => 3,
69            Self::Millimeter => 4,
70            Self::Centimeter => 5,
71            Self::Meter => 6,
72            Self::Kilometer => 7,
73            Self::Microinch => 8,
74            Self::Mil => 9,
75            Self::Yard => 10,
76            Self::Angstrom => 11,
77            Self::Nanometer => 12,
78            Self::Micrometer => 13,
79            Self::Decimeter => 14,
80            Self::Decameter => 15,
81            Self::Hectometer => 16,
82            Self::Gigameter => 17,
83            Self::AstronomicalUnit => 18,
84            Self::LightYear => 19,
85            Self::Parsec => 20,
86            Self::UsSurveyFoot => 21,
87        }
88    }
89
90    /// Canonical lowercase snake_case name of this unit.
91    pub const fn as_str(self) -> &'static str {
92        match self {
93            Self::Unitless => "unitless",
94            Self::Inch => "inch",
95            Self::Foot => "foot",
96            Self::Mile => "mile",
97            Self::Millimeter => "millimeter",
98            Self::Centimeter => "centimeter",
99            Self::Meter => "meter",
100            Self::Kilometer => "kilometer",
101            Self::Microinch => "microinch",
102            Self::Mil => "mil",
103            Self::Yard => "yard",
104            Self::Angstrom => "angstrom",
105            Self::Nanometer => "nanometer",
106            Self::Micrometer => "micrometer",
107            Self::Decimeter => "decimeter",
108            Self::Decameter => "decameter",
109            Self::Hectometer => "hectometer",
110            Self::Gigameter => "gigameter",
111            Self::AstronomicalUnit => "astronomical_unit",
112            Self::LightYear => "light_year",
113            Self::Parsec => "parsec",
114            Self::UsSurveyFoot => "us_survey_foot",
115            Self::Custom => "custom",
116        }
117    }
118
119    /// Parses a common unit symbol or name (case-insensitive, e.g. `"mm"`, `"meter"`, `"ft"`).
120    pub fn from_name(name: &str) -> Option<Self> {
121        let lower = name.trim().to_ascii_lowercase();
122        Some(match lower.as_str() {
123            "unitless" | "none" => Self::Unitless,
124            "in" | "inch" | "inches" => Self::Inch,
125            "ft" | "foot" | "feet" => Self::Foot,
126            "mi" | "mile" | "miles" => Self::Mile,
127            "mm" | "millimeter" | "millimeters" | "millimetre" | "millimetres" => Self::Millimeter,
128            "cm" | "centimeter" | "centimeters" | "centimetre" | "centimetres" => Self::Centimeter,
129            "m" | "meter" | "meters" | "metre" | "metres" => Self::Meter,
130            "km" | "kilometer" | "kilometers" | "kilometre" | "kilometres" => Self::Kilometer,
131            "uin" | "microinch" | "microinches" => Self::Microinch,
132            "mil" | "mils" => Self::Mil,
133            "yd" | "yard" | "yards" => Self::Yard,
134            "angstrom" | "angstroms" => Self::Angstrom,
135            "nm" | "nanometer" | "nanometers" | "nanometre" | "nanometres" => Self::Nanometer,
136            "um" | "micrometer" | "micrometers" | "micrometre" | "micrometres" | "micron" => {
137                Self::Micrometer
138            }
139            "dm" | "decimeter" | "decimeters" | "decimetre" | "decimetres" => Self::Decimeter,
140            "dam" | "decameter" | "decameters" | "decametre" | "decametres" => Self::Decameter,
141            "hm" | "hectometer" | "hectometers" | "hectometre" | "hectometres" => Self::Hectometer,
142            "gm" | "gigameter" | "gigameters" | "gigametre" | "gigametres" => Self::Gigameter,
143            "au" | "astronomical_unit" | "astronomical-unit" => Self::AstronomicalUnit,
144            "ly" | "light_year" | "light-year" => Self::LightYear,
145            "pc" | "parsec" | "parsecs" => Self::Parsec,
146            "us_ft" | "us-ft" | "us_survey_foot" | "us-survey-foot" | "survey_foot" => {
147                Self::UsSurveyFoot
148            }
149            "custom" => Self::Custom,
150            _ => return None,
151        })
152    }
153}
154
155impl Units {
156    /// Size of one drawing unit in meters. The explicit `meters_per_unit` field wins when it is
157    /// a positive finite number; otherwise the named unit is used. `None` when unknown.
158    pub fn meters_per_unit(&self) -> Option<f64> {
159        match self.meters_per_unit {
160            Some(m) if m.is_finite() && m > 0.0 => Some(m),
161            _ => self.unit.meters(),
162        }
163    }
164
165    /// Maps a DWG/DXF `$INSUNITS` code (`0..=24`) to [`Units`], preserving US Survey inch (`22`),
166    /// yard (`23`), and mile (`24`) via [`LengthUnit::Custom`] and exact meter conversion factors.
167    pub fn from_insunits(code: i32) -> Self {
168        match code {
169            22 => Self {
170                unit: LengthUnit::Custom,
171                meters_per_unit: Some(100.0 / 3937.0),
172            },
173            23 => Self {
174                unit: LengthUnit::Custom,
175                meters_per_unit: Some(3600.0 / 3937.0),
176            },
177            24 => Self {
178                unit: LengthUnit::Custom,
179                meters_per_unit: Some(6_336_000.0 / 3937.0),
180            },
181            _ => {
182                let unit = LengthUnit::from_insunits(code);
183                Self {
184                    unit,
185                    meters_per_unit: unit.meters(),
186                }
187            }
188        }
189    }
190
191    /// Converts these units back to a DWG/DXF `$INSUNITS` code (`0..=24`), recognizing US Survey
192    /// inch (`22`), yard (`23`), and mile (`24`) when [`LengthUnit::Custom`] carries their meter factor.
193    pub fn to_insunits(&self) -> i32 {
194        if self.unit == LengthUnit::Custom {
195            match self.meters_per_unit {
196                Some(m) if (m - 100.0 / 3937.0).abs() < 1e-9 => 22,
197                Some(m) if (m - 3600.0 / 3937.0).abs() < 1e-9 => 23,
198                Some(m) if (m - 6_336_000.0 / 3937.0).abs() < 1e-6 => 24,
199                _ => 0,
200            }
201        } else {
202            self.unit.to_insunits()
203        }
204    }
205}
206
207#[cfg(test)]
208mod tests {
209    use super::*;
210
211    #[test]
212    fn meters() {
213        assert_eq!(LengthUnit::Millimeter.meters(), Some(0.001));
214        assert_eq!(LengthUnit::Unitless.meters(), None);
215        assert_eq!(LengthUnit::Custom.meters(), None);
216        assert!((LengthUnit::Foot.meters().unwrap() - 0.3048).abs() < 1e-12);
217    }
218
219    #[test]
220    fn insunits_roundtrip() {
221        for code in 0..=21 {
222            assert_eq!(LengthUnit::from_insunits(code).to_insunits(), code);
223        }
224        for code in 0..=24 {
225            let u = Units::from_insunits(code);
226            assert_eq!(u.to_insunits(), code, "code {code} failed roundtrip");
227            if code >= 1 {
228                assert!(u.meters_per_unit().is_some());
229            }
230        }
231        assert_eq!(LengthUnit::from_insunits(99), LengthUnit::Unitless);
232        assert_eq!(LengthUnit::from_insunits(-1), LengthUnit::Unitless);
233        assert_eq!(Units::from_insunits(99).to_insunits(), 0);
234        assert_eq!(LengthUnit::Custom.to_insunits(), 0);
235    }
236
237    #[test]
238    fn explicit_field_preferred() {
239        let u = Units {
240            unit: LengthUnit::Meter,
241            meters_per_unit: Some(0.5),
242        };
243        assert_eq!(u.meters_per_unit(), Some(0.5));
244        let u = Units {
245            unit: LengthUnit::Meter,
246            meters_per_unit: None,
247        };
248        assert_eq!(u.meters_per_unit(), Some(1.0));
249        let u = Units {
250            unit: LengthUnit::Meter,
251            meters_per_unit: Some(f64::NAN),
252        };
253        assert_eq!(u.meters_per_unit(), Some(1.0));
254        let u = Units {
255            unit: LengthUnit::Custom,
256            meters_per_unit: Some(0.01),
257        };
258        assert_eq!(u.meters_per_unit(), Some(0.01));
259        assert_eq!(Units::default().meters_per_unit(), None);
260    }
261}