use serde::{Deserialize, Serialize};
use crate::*;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImportedBody {
pub name: Option<String>,
#[serde(default)]
pub mesh: TriMesh,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub brep_blob: Vec<u8>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub face_colors: Vec<[f32; 3]>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bounds_mm: Option<([f32; 3], [f32; 3])>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub health: Option<ShapeHealth>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub layers: Vec<String>,
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ShapeHealth {
pub broken: usize,
pub suspect: usize,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub findings: Vec<String>,
#[serde(default)]
pub repaired: bool,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub faceted: bool,
}
impl ShapeHealth {
pub const KEPT_FINDINGS: usize = 8;
pub fn is_broken(&self) -> bool {
self.broken > 0
}
pub fn describe(&self) -> String {
let mut lines = Vec::new();
let counts = match (self.broken, self.suspect) {
(0, 0) => "The shape checks clean".to_string(),
(b, 0) => format!("{b} shape defect(s) that make operations answer wrongly"),
(0, s) => format!("{s} shape irregularity(ies), harmless to operations"),
(b, s) => format!(
"{b} shape defect(s) that make operations answer wrongly, \
and {s} harmless irregularity(ies)"
),
};
lines.push(counts);
if self.repaired && self.is_broken() {
lines.push("Repaired; these remain, beyond what the repair mends".to_string());
}
lines.extend(self.findings.iter().cloned());
let shown = self.findings.len();
let total = self.broken + self.suspect;
if total > shown {
lines.push(format!("… and {} more", total - shown));
}
lines.join("\n")
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct RepairResult {
pub brep_blob: Vec<u8>,
pub face_colors: Vec<[f32; 3]>,
pub mesh: TriMesh,
pub bounds_mm: Option<([f32; 3], [f32; 3])>,
pub health: ShapeHealth,
pub mended: Vec<String>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct MeshSolidResult {
pub brep_blob: Vec<u8>,
pub face_colors: Vec<[f32; 3]>,
pub mesh: TriMesh,
pub bounds_mm: Option<([f32; 3], [f32; 3])>,
pub health: ShapeHealth,
pub closed: bool,
pub summary: Vec<String>,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct PhysicalProperties {
pub volume_mm3: Option<f64>,
pub area_mm2: f64,
pub centre_mm: [f64; 3],
#[serde(default)]
pub approximate: bool,
#[serde(default)]
pub inertia: Option<Inertia>,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct Inertia {
pub about_centre: [[f64; 3]; 3],
pub principal: [(f64, [f64; 3]); 3],
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum ImportedNodeKind {
#[default]
Assembly,
Part,
Instance,
Annotations,
Annotation,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "snake_case")]
pub enum AnnotationKind {
Dimension,
Tolerance,
Datum,
Note,
#[default]
Other,
}
impl AnnotationKind {
pub fn label(self) -> &'static str {
match self {
AnnotationKind::Dimension => "Dimension",
AnnotationKind::Tolerance => "Tolerance",
AnnotationKind::Datum => "Datum",
AnnotationKind::Note => "Note",
AnnotationKind::Other => "Annotation",
}
}
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct ImportedAnnotation {
pub name: String,
pub kind: AnnotationKind,
pub text: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub polylines: Vec<Vec<[f32; 3]>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub anchor: Option<[f32; 3]>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub body_index: Option<usize>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImportedNode {
pub id: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parent_id: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default)]
pub kind: ImportedNodeKind,
#[serde(default = "default_imported_node_visible")]
pub visible: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub body_index: Option<usize>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub local_transform: Option<[[f32; 4]; 4]>,
}
fn default_imported_node_visible() -> bool {
true
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LengthUnit {
Millimetre,
Centimetre,
Metre,
Inch,
Foot,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ImportedModel {
pub bodies: Vec<ImportedBody>,
#[serde(default)]
pub report: ImportReport,
#[serde(default)]
pub nodes: Vec<ImportedNode>,
#[serde(default)]
pub source_unit: Option<LengthUnit>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub annotations: Vec<ImportedAnnotation>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ImportReport {
pub kernel: String,
pub summary: Vec<ImportWarningKind>,
pub warnings: Vec<String>,
pub untrimmed_faces: Vec<u64>,
pub skipped: Vec<(String, usize)>,
}
impl ImportReport {
pub fn is_clean(&self) -> bool {
self.warnings.is_empty() && self.untrimmed_faces.is_empty()
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ImportWarningKind {
pub kind: String,
pub count: usize,
pub worst: f64,
pub exemplar: u64,
}