conspire 0.7.1

The Rust interface to conspire.
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

#[cfg(test)]
mod test;

use crate::{
    geometry::mesh::{Connectivity, tessellation::Tessellation},
    io::Write,
    math::Tensor,
};
use std::{
    fs::File,
    io::{BufWriter, Error as ErrorIO, Write as WriteIO},
    path::Path,
};

impl<P> Write<P> for Tessellation
where
    P: AsRef<Path>,
{
    type Error = ErrorIO;
    fn write(&self, path: P) -> Result<(), Self::Error> {
        let mut writer = BufWriter::new(File::create(path)?);
        writer.write_all(&[0_u8; 80])?;
        writer.write_all(&(self.mesh.number_of_elements() as u32).to_le_bytes())?;
        self.mesh
            .connectivities()
            .iter()
            .zip(self.normals.iter())
            .try_for_each(|(connectivity, normals)| match connectivity {
                Connectivity::Triangular(triangles) => triangles
                    .iter()
                    .zip(normals.iter())
                    .try_for_each(|(nodes, normal)| {
                        normal.iter().try_for_each(|&component| {
                            writer.write_all(&(component as f32).to_le_bytes())
                        })?;
                        nodes.iter().try_for_each(|&node| {
                            self.mesh.coordinates()[node]
                                .iter()
                                .try_for_each(|&coordinate| {
                                    writer.write_all(&(coordinate as f32).to_le_bytes())
                                })
                        })?;
                        writer.write_all(&0_u16.to_le_bytes())
                    }),
                _ => panic!("STL only supports triangular blocks"),
            })?;
        writer.flush()
    }
}