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

//! # meshvox
//! A simple CPU based mesh voxelizer written in rust.
//!
//! ## Example
//!
//! ```rust
//! use meshvox::Voxels;
//! use std::fs::File;
//! use std::io::{BufWriter, Write};
//! 
//! fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     let p0 = [0.0, 0.0, 1.0];
//!     let p1 = [1.0, 0.0, 0.0];
//!     let p2 = [0.0, 1.0, 0.0];
//!     let p3 = [-1.0, 0.0, 0.0];
//!     let p4 = [0.0, -1.0, 0.0];
//! 
//!     let i0 = [0, 2, 1];
//!     let i1 = [0, 1, 4];
//!     let i2 = [0, 4, 3];
//!     let i3 = [0, 3, 2];
//!     let i4 = [2, 3, 4];
//!     let i5 = [2, 4, 1];
//! 
//!     let vertices = vec![p0, p1, p2, p3, p4];
//!     let indices = vec![i0, i1, i2, i3, i4, i5]
//!         .iter()
//!         .flatten()
//!         .map(|i| *i)
//!         .collect::<Vec<_>>();
//! 
//!     let box_size = 0.05;
//!     let pyramid = Voxels::voxelize(&vertices, &indices, box_size);
//!     let (v, i) = pyramid.vertices_indices();
//! 
//!     let file = File::create("examples/pyramid.obj")?;
//!     let mut file = BufWriter::new(file);
//!     for vertex in v {
//!         writeln!(
//!             file,
//!             "v {:0.6} {:0.6} {:0.6}",
//!             vertex[0], vertex[1], vertex[2]
//!         );
//!     }
//!     for index in i.iter().step_by(3) {
//!         writeln!(file, "f {} {} {}", index + 1, index + 2, index + 3);
//!     }
//!     file.flush()?;
//! 
//!     Ok(())
//! }
//! ```

pub(crate) mod sat;
pub(crate) mod vector;
pub mod voxelize;
//pub(crate) mod greedy_mesh;

pub use voxelize::*;