thdmaker 0.0.4

A comprehensive 3D file format library supporting AMF, STL, 3MF and other 3D manufacturing formats
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

use std::io::BufRead;
use quick_xml::events::{BytesStart, Event};
use quick_xml::Reader;
use super::error::{Error, Result};
use super::define::trianglesets::*;

impl TriangleSets {
    pub fn parse<R: BufRead>(reader: &mut Reader<R>) -> Result<Self> {
        let mut triangle_sets = Vec::new();
        let mut buf = Vec::new();
    
        loop {
            match reader.read_event_into(&mut buf) {
                Ok(Event::Start(ref e)) if e.local_name().as_ref() == b"triangleset" => {
                    let set = TriangleSet::parse(reader, e)?;
                    triangle_sets.push(set);
                }
                Ok(Event::Empty(ref e)) if e.local_name().as_ref() == b"triangleset" => {
                    let set = TriangleSet::attributes(e)?;
                    triangle_sets.push(set);
                }
                Ok(Event::End(ref e)) if e.local_name().as_ref() == b"trianglesets" => break,
                Ok(Event::Eof) => return Err(Error::UnexpectedEofIn("trianglesets".to_string())),
                Ok(_) => {}
                Err(e) => return Err(Error::Xml(e)),
            }
            buf.clear();
        }
    
        Ok(Self { triangle_sets })
    }
}

impl TriangleSet {
    fn parse<R: BufRead>(reader: &mut Reader<R>, elem: &BytesStart) -> Result<Self> {
        let mut set = Self::attributes(elem)?;
        let mut buf = Vec::new();
    
        loop {
            match reader.read_event_into(&mut buf) {
                Ok(Event::Empty(ref e)) if e.local_name().as_ref() == b"ref" => {
                    let r = TriangleRef::parse(e)?;
                    set.r#ref.push(r);
                }
                Ok(Event::Empty(ref e)) if e.local_name().as_ref() == b"refrange" => {
                    let range = TriangleRefRange::parse(e)?;
                    set.refrange.push(range);
                }
                Ok(Event::End(ref e)) if e.local_name().as_ref() == b"triangleset" => break,
                Ok(Event::Eof) => return Err(Error::UnexpectedEofIn("triangleset".to_string())),
                Ok(_) => {}
                Err(e) => return Err(Error::Xml(e)),
            }
            buf.clear();
        }
    
        Ok(set)
    }

    fn attributes(elem: &BytesStart) -> Result<Self> {
        let mut name = String::new();
        let mut identifier = String::new();
    
        for attr in elem.attributes().flatten() {
            let key = attr.key.as_ref();
            let value = attr.unescape_value()?;
    
            match key {
                b"name" => name = value.to_string(),
                b"identifier" => identifier = value.to_string(),
                _ => {}
            }
        }
    
        Ok(Self {
            name,
            identifier,
            r#ref: Vec::new(),
            refrange: Vec::new(),
        })
    }
}

impl TriangleRef {
    fn parse(elem: &BytesStart) -> Result<Self> {
        let mut index = 0usize;
    
        for attr in elem.attributes().flatten() {
            let key = attr.key.as_ref();
            let value = attr.unescape_value()?;
    
            if key == b"index" {
                index = value.parse()?;
            }
        }
    
        Ok(Self { index })
    }
}

impl TriangleRefRange {
    fn parse(elem: &BytesStart) -> Result<Self> {
        let mut start_index = 0usize;
        let mut end_index = 0usize;
    
        for attr in elem.attributes().flatten() {
            let key = attr.key.as_ref();
            let value = attr.unescape_value()?;
    
            match key {
                b"startindex" => start_index = value.parse()?,
                b"endindex" => end_index = value.parse()?,
                _ => {}
            }
        }
    
        Ok(Self { start_index, end_index })
    }
}