acadrust 0.6.7

A pure Rust library for reading and writing CAD files in DXF format (ASCII and Binary) and DWG format (Binary).
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

//! Solid entity (filled quadrilateral)

use crate::entities::{Entity, EntityCommon};
use crate::types::{BoundingBox3D, Vector3};

/// Solid entity - a filled quadrilateral (3 or 4 vertices)
///
/// A Solid entity is a filled shape defined by 3 or 4 corner points.
/// If only 3 corners are provided, the fourth corner is the same as the third.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Solid {
    pub common: EntityCommon,
    /// First corner point (in OCS)
    pub first_corner: Vector3,
    /// Second corner point (in OCS)
    pub second_corner: Vector3,
    /// Third corner point (in OCS)
    pub third_corner: Vector3,
    /// Fourth corner point (in OCS) - same as third if only 3 corners
    pub fourth_corner: Vector3,
    /// Normal vector (extrusion direction)
    pub normal: Vector3,
    /// Thickness (extrusion distance)
    pub thickness: f64,
    /// Preserve the legacy TRACE entity identity. TRACE and SOLID share the
    /// same geometry but use different DWG/DXF type codes.
    pub is_trace: bool,
}

impl Solid {
    /// Create a new solid with four corners
    pub fn new(first: Vector3, second: Vector3, third: Vector3, fourth: Vector3) -> Self {
        Self {
            common: EntityCommon::default(),
            first_corner: first,
            second_corner: second,
            third_corner: third,
            fourth_corner: fourth,
            normal: Vector3::new(0.0, 0.0, 1.0),
            thickness: 0.0,
            is_trace: false,
        }
    }

    /// Create a triangular solid (3 corners)
    pub fn triangle(first: Vector3, second: Vector3, third: Vector3) -> Self {
        Self::new(first, second, third, third)
    }

    /// Builder: Set the normal vector
    pub fn with_normal(mut self, normal: Vector3) -> Self {
        self.normal = normal;
        self
    }

    /// Builder: Set the thickness
    pub fn with_thickness(mut self, thickness: f64) -> Self {
        self.thickness = thickness;
        self
    }

    /// Check if this is a triangle (3 vertices)
    pub fn is_triangle(&self) -> bool {
        (self.third_corner - self.fourth_corner).length() < 1e-10
    }

    /// Get all corner points
    pub fn corners(&self) -> Vec<Vector3> {
        if self.is_triangle() {
            vec![self.first_corner, self.second_corner, self.third_corner]
        } else {
            vec![
                self.first_corner,
                self.second_corner,
                self.third_corner,
                self.fourth_corner,
            ]
        }
    }

    /// Get corners in visible boundary order.
    /// Stored quadrilaterals use first, second, fourth, third.
    pub fn boundary_corners(&self) -> Vec<Vector3> {
        if self.is_triangle() {
            vec![self.first_corner, self.second_corner, self.third_corner]
        } else {
            vec![
                self.first_corner,
                self.second_corner,
                self.fourth_corner,
                self.third_corner,
            ]
        }
    }
}

impl Entity for Solid {
    fn common(&self) -> &super::EntityCommon {
        &self.common
    }

    fn common_mut(&mut self) -> &mut super::EntityCommon {
        &mut self.common
    }

    fn bounding_box(&self) -> BoundingBox3D {
        BoundingBox3D::from_points(&self.corners())
            .unwrap_or_else(|| {
                BoundingBox3D::new(Vector3::new(0.0, 0.0, 0.0), Vector3::new(0.0, 0.0, 0.0))
            })
            .ocs_to_wcs(self.normal)
    }

    fn translate(&mut self, offset: Vector3) {
        super::translate::translate_solid(self, offset);
    }

    fn entity_type(&self) -> &'static str {
        "SOLID"
    }

    fn apply_transform(&mut self, transform: &crate::types::Transform) {
        super::transform::transform_solid(self, transform);
    }

    fn apply_mirror(&mut self, transform: &crate::types::Transform) {
        super::mirror::mirror_solid(self, transform);
    }
}