runmat-geometry-core 0.5.4

Canonical geometry domain model for RunMat
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use serde::{Deserialize, Serialize};

use crate::selection::EntityKind;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Region {
    pub region_id: String,
    pub name: String,
    pub tag: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cad_ownership: Option<CadRegionOwnership>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum CadSemanticKind {
    Assembly,
    Component,
    Reference,
    Body,
    Compound,
    Face,
    Subshape,
    Layer,
    Color,
    Material,
    Shape,
    Unknown,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CadLabelRef {
    pub label_entry: String,
    pub name: String,
    pub kind: CadSemanticKind,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CadColorEvidence {
    pub source: String,
    pub color_type: String,
    pub hex_rgba: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CadPhysicalMaterialEvidence {
    pub label_entry: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub density: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub density_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub density_value_type: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CadRegionOwnership {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub face_id: Option<u64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub label: Option<CadLabelRef>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub owner_path: Vec<CadLabelRef>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub layers: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub color: Option<CadColorEvidence>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub material: Option<CadPhysicalMaterialEvidence>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EntityIdRange {
    pub start: u64,
    pub count: u64,
}

impl EntityIdRange {
    pub fn new(start: u64, count: u64) -> Self {
        Self { start, count }
    }

    pub fn end_exclusive(&self) -> Option<u64> {
        self.start.checked_add(self.count)
    }

    pub fn contains(&self, entity_id: u64) -> bool {
        self.end_exclusive()
            .is_some_and(|end| entity_id >= self.start && entity_id < end)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RegionEntityMapping {
    pub region_id: String,
    pub mesh_id: String,
    pub entity_kind: EntityKind,
    pub ranges: Vec<EntityIdRange>,
}

impl RegionEntityMapping {
    pub fn new(
        region_id: impl Into<String>,
        mesh_id: impl Into<String>,
        entity_kind: EntityKind,
        ranges: Vec<EntityIdRange>,
    ) -> Self {
        Self {
            region_id: region_id.into(),
            mesh_id: mesh_id.into(),
            entity_kind,
            ranges,
        }
    }

    pub fn all_faces(
        region_id: impl Into<String>,
        mesh_id: impl Into<String>,
        face_count: u64,
    ) -> Self {
        Self::new(
            region_id,
            mesh_id,
            EntityKind::Face,
            if face_count == 0 {
                Vec::new()
            } else {
                vec![EntityIdRange::new(0, face_count)]
            },
        )
    }

    pub fn entity_count(&self) -> u64 {
        self.ranges.iter().map(|range| range.count).sum()
    }

    pub fn contains_entity(&self, entity_id: u64) -> bool {
        self.ranges.iter().any(|range| range.contains(entity_id))
    }
}