acadrust 0.3.4

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Example: Serialize and deserialize CAD data with serde + JSON.
//!
//! Run with:
//!
//! ```bash
//! cargo run --example serde_json --features serde
//! ```
//!
//! This example demonstrates several practical use-cases:
//!
//! 1. Serialize individual entities to JSON
//! 2. Serialize an entire `CadDocument` to JSON and back
//! 3. Serialize selected entity types for a web API response
//! 4. Primitive type serialization
//! 5. Full pipeline: DXF → JSON → DXF (read → serialize → deserialize → write)

use acadrust::entities::*;
use acadrust::types::{Color, Vector3};
use acadrust::{CadDocument, DxfWriter};

fn main() -> acadrust::Result<()> {
    // ── 1. Serialize individual entities ────────────────────────────

    println!("═══ 1. Individual Entity Serialization ═══\n");

    let line = Line::from_coords(0.0, 0.0, 0.0, 100.0, 50.0, 0.0);
    let json = serde_json::to_string_pretty(&line).unwrap();
    println!("Line as JSON:\n{}\n", json);

    let circle = Circle::from_coords(50.0, 25.0, 0.0, 15.0);
    let json = serde_json::to_string_pretty(&circle).unwrap();
    println!("Circle as JSON:\n{}\n", json);

    // Deserialize back
    let circle2: Circle = serde_json::from_str(&json).unwrap();
    println!(
        "Deserialized circle: center={:?}, radius={}\n",
        circle2.center, circle2.radius
    );

    // ── 2. Full document round-trip ────────────────────────────────

    println!("═══ 2. Full Document Round-trip ═══\n");

    let mut doc = CadDocument::new();

    // Add some entities
    let mut line = Line::from_coords(0.0, 0.0, 0.0, 200.0, 100.0, 0.0);
    line.common.color = Color::from_index(1); // Red
    doc.add_entity(EntityType::Line(line))?;

    let mut circle = Circle::from_coords(100.0, 50.0, 0.0, 30.0);
    circle.common.color = Color::from_index(3); // Green
    doc.add_entity(EntityType::Circle(circle))?;

    let arc = Arc::from_center_radius_angles(
        Vector3::new(50.0, 50.0, 0.0),
        25.0,
        0.0,
        std::f64::consts::FRAC_PI_2,
    );
    doc.add_entity(EntityType::Arc(arc))?;

    // Serialize the entire document
    let doc_json = serde_json::to_string_pretty(&doc).unwrap();
    println!("Document JSON length: {} bytes", doc_json.len());

    // Deserialize back
    let doc2: CadDocument = serde_json::from_str(&doc_json).unwrap();
    println!(
        "Deserialized document: {} entities, version={:?}\n",
        doc2.entities().count(),
        doc2.version
    );

    // ── 3. Extract entities as a JSON array (web API style) ────────

    println!("═══ 3. Web API Style — Entity List ═══\n");

    // Collect entities into a Vec for serialization
    let entities: Vec<&EntityType> = doc.entities().collect();
    let api_json = serde_json::to_string_pretty(&entities).unwrap();
    println!("Entities array JSON:\n{}\n", api_json);

    // ── 4. Serialize types directly ────────────────────────────────

    println!("═══ 4. Primitive Types ═══\n");

    let point = Vector3::new(42.0, 17.5, -3.0);
    println!("Vector3: {}", serde_json::to_string(&point).unwrap());

    let color = Color::Rgb {
        r: 255,
        g: 128,
        b: 0,
    };
    println!("Color:   {}", serde_json::to_string(&color).unwrap());

    // ── 5. Full pipeline: DXF → JSON → DXF ────────────────────────

    println!("\n═══ 5. Full Pipeline: DXF → JSON → DXF ═══\n");

    // Build a document with several entities (simulates reading a file)
    let mut source = CadDocument::new();

    let mut line = Line::from_coords(10.0, 20.0, 0.0, 300.0, 150.0, 0.0);
    line.common.color = Color::from_index(1);
    source.add_entity(EntityType::Line(line))?;

    let mut circle = Circle::from_coords(150.0, 75.0, 0.0, 40.0);
    circle.common.color = Color::from_index(5);
    source.add_entity(EntityType::Circle(circle))?;

    let arc = Arc::from_center_radius_angles(
        Vector3::new(80.0, 80.0, 0.0),
        20.0,
        0.0,
        std::f64::consts::PI,
    );
    source.add_entity(EntityType::Arc(arc))?;

    println!(
        "Source document: {} entities, version={:?}",
        source.entities().count(),
        source.version
    );

    // ── Serialize to JSON (e.g. send to a web client / store in DB) ──
    let json = serde_json::to_string(&source).unwrap();
    println!("Serialized to JSON: {} bytes", json.len());

    // ── Deserialize back (e.g. received from web client) ──
    let restored: CadDocument = serde_json::from_str(&json).unwrap();
    println!(
        "Deserialized back:  {} entities, version={:?}",
        restored.entities().count(),
        restored.version
    );

    // ── Write the restored document to DXF ──
    let output_path = "target/serde_roundtrip.dxf";
    DxfWriter::new(&restored).write_to_file(output_path)?;
    let file_size = std::fs::metadata(output_path).unwrap().len();
    println!("Written to {output_path}: {file_size} bytes");

    // ── Verify: read the written file back ──
    let verify = acadrust::DxfReader::from_file(output_path)?.read()?;
    println!(
        "Verified:           {} entities, version={:?}",
        verify.entities().count(),
        verify.version
    );

    println!("\nDone!");

    Ok(())
}