Struct truck_polymesh::Faces

pub struct Faces<V = StandardVertex> { /* private fields */ }

Faces of polygon mesh

To optimize for the case where the polygon mesh consists only triangles and quadrangle, there are vectors which consist by each triangles and quadrilaterals, internally.

Implementations

impl<V: Copy> Faces<V>

pub fn extend<U: Copy + Into<V>, T: AsRef<[U]>, I: IntoIterator<Item = T>>(
    &mut self,
    iter: I
)

Extends faces by an iterator.

Examples found in repository

src/faces.rs (line 96)

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Faces {
        let mut faces = Faces::default();
        faces.extend(iter);
        faces
    }
}

impl<S: AsRef<[usize]>> FromIterator<S> for Faces<usize> {
    #[inline(always)]
    fn from_iter<I: IntoIterator<Item = S>>(iter: I) -> Faces<usize> {
        let mut faces = Faces::default();
        faces.extend(iter);
        faces
    }

pub const fn from_tri_and_quad_faces(
    tri_faces: Vec<[V; 3]>,
    quad_faces: Vec<[V; 4]>
) -> Self

Creates faces of a polygon mesh by the vectors of triangle and quadrangle.

Examples

// Creates faces consisis only triangles.
use truck_polymesh::*;
let tri_faces: Vec<[StandardVertex; 3]> = vec![
    [[0, 0, 0].into(), [1, 1, 1].into(), [2, 2, 2].into()],
    [[0, 0, 0].into(), [2, 2, 2].into(), [3, 3, 3].into()],
];
let faces = Faces::from_tri_and_quad_faces(tri_faces, Vec::new());

Examples found in repository

src/stl.rs (line 317)

    fn from_iter<I: IntoIterator<Item = STLFace>>(iter: I) -> PolygonMesh {
        let mut positions = HashMap::<[i64; 3], usize>::default();
        let mut normals = HashMap::<[i64; 3], usize>::default();
        let faces: Vec<[Vertex; 3]> = iter
            .into_iter()
            .map(|face| {
                let n = signup_vector(face.normal, &mut normals);
                let p = [
                    signup_vector(face.vertices[0], &mut positions),
                    signup_vector(face.vertices[1], &mut positions),
                    signup_vector(face.vertices[2], &mut positions),
                ];
                [
                    (p[0], None, Some(n)).into(),
                    (p[1], None, Some(n)).into(),
                    (p[2], None, Some(n)).into(),
                ]
            })
            .collect();
        let faces = Faces::from_tri_and_quad_faces(faces, Vec::new());
        let mut positions: Vec<([i64; 3], usize)> = positions.into_iter().collect();
        positions.sort_by(|a, b| a.1.cmp(&b.1));
        let positions: Vec<Point3> = positions
            .into_iter()
            .map(|(p, _)| {
                Point3::new(
                    p[0] as f64 * TOLERANCE * 0.5,
                    p[1] as f64 * TOLERANCE * 0.5,
                    p[2] as f64 * TOLERANCE * 0.5,
                )
            })
            .collect();
        let mut normals: Vec<([i64; 3], usize)> = normals.into_iter().collect();
        normals.sort_by(|a, b| a.1.cmp(&b.1));
        let normals: Vec<Vector3> = normals
            .into_iter()
            .map(|(p, _)| {
                Vector3::new(
                    p[0] as f64 * TOLERANCE * 0.5,
                    p[1] as f64 * TOLERANCE * 0.5,
                    p[2] as f64 * TOLERANCE * 0.5,
                )
            })
            .collect();
        PolygonMesh::debug_new(
            StandardAttributes {
                positions,
                uv_coords: Vec::new(),
                normals,
            },
            faces,
        )
    }

pub fn push<U: Copy + Into<V>, T: AsRef<[U]>>(&mut self, face: T)

Push a face to the faces.

If face.len() < 3, the face is ignored with warning.

Examples

use truck_polymesh::*;
let mut faces = Faces::<StandardVertex>::default(); // empty faces
faces.push(&[[0, 0, 0], [1, 1, 1], [2, 2, 2]]);
faces.push(&[[3, 3, 3], [0, 0, 0], [2, 2, 2]]);
faces.push(&[[0, 0, 0], [4, 4, 4], [5, 5, 5], [1, 1, 1]]);
faces.push(&[[100, 1000, 10]]); // Wargning: ignored one vertex "face"

Examples found in repository

src/faces.rs (line 124)

    pub fn extend<U: Copy + Into<V>, T: AsRef<[U]>, I: IntoIterator<Item = T>>(&mut self, iter: I) {
        iter.into_iter().for_each(|face| self.push(face))
    }

src/obj.rs (line 174)

pub fn read<R: Read>(reader: R) -> Result<PolygonMesh> {
    let mut positions = Vec::new();
    let mut uv_coords = Vec::new();
    let mut normals = Vec::new();
    let mut faces = Faces::default();
    let reader = BufReader::new(reader);
    for line in reader.lines().map(|s| s.unwrap()) {
        let mut args = line.split_whitespace();
        if let Some(first_str) = args.next() {
            if first_str == "v" {
                let x = args.next().unwrap().parse::<f64>()?;
                let y = args.next().unwrap().parse::<f64>()?;
                let z = args.next().unwrap().parse::<f64>()?;
                positions.push(Point3::new(x, y, z));
            } else if first_str == "vt" {
                let u = args.next().unwrap().parse::<f64>()?;
                let v = args.next().unwrap().parse::<f64>()?;
                uv_coords.push(Vector2::new(u, v));
            } else if first_str == "vn" {
                let x = args.next().unwrap().parse::<f64>()?;
                let y = args.next().unwrap().parse::<f64>()?;
                let z = args.next().unwrap().parse::<f64>()?;
                normals.push(Vector3::new(x, y, z));
            } else if first_str == "f" {
                let mut face = Vec::new();
                for vert_str in args {
                    if &vert_str[0..1] == "#" {
                        break;
                    }
                    let mut iter = vert_str.split('/');
                    let pos = iter
                        .next()
                        .map(|val| val.parse::<usize>().map(|i| i - 1).ok())
                        .unwrap_or(None);
                    let uv = iter
                        .next()
                        .map(|val| val.parse::<usize>().map(|i| i - 1).ok())
                        .unwrap_or(None);
                    let nor = iter
                        .next()
                        .map(|val| val.parse::<usize>().map(|i| i - 1).ok())
                        .unwrap_or(None);
                    let vert = match (pos, uv, nor) {
                        (None, _, _) => continue,
                        (Some(pos), uv, nor) => Vertex { pos, uv, nor },
                    };
                    face.push(vert);
                }
                faces.push(face);
            }
        }
    }
    PolygonMesh::try_new(
        StandardAttributes {
            positions,
            uv_coords,
            normals,
        },
        faces,
    )
}

pub const fn tri_faces(&self) -> &Vec<[V; 3]>

Returns the vector of triangles.

pub fn tri_faces_mut(&mut self) -> &mut [[V; 3]]

Returns the mutable slice of triangles.

pub const fn quad_faces(&self) -> &Vec<[V; 4]>

Returns the vector of quadrangles.

pub fn quad_faces_mut(&mut self) -> &mut [[V; 4]]

Returns the mutable slice of quadrangles.

pub const fn other_faces(&self) -> &Vec<Vec<V>>

Returns the vector of n-gons (n > 4).

pub fn other_faces_mut(&mut self) -> impl Iterator<Item = &mut [V]>

Returns the mutable iterator of n-gons (n > 4).

pub fn face_iter(&self) -> impl Iterator<Item = &[V]>

Returns the iterator of the slice.

By the internal optimization, this iterator does not runs in the simple order in which they are registered, but runs order: triangle, square, and the others.

Examples

use truck_polymesh::*;
let slice: &[&[usize]] = &[
    &[0, 1, 2],
    &[0, 4, 5, 1],
    &[1, 2, 6, 7, 8, 9],
    &[0, 2, 3],
];
let faces = Faces::<usize>::from_iter(slice);
let mut iter = faces.face_iter();
assert_eq!(iter.next(), Some([0, 1, 2].as_ref()));
assert_eq!(iter.next(), Some([0, 2, 3].as_ref()));
assert_eq!(iter.next(), Some([0, 4, 5, 1].as_ref()));
assert_eq!(iter.next(), Some([1, 2, 6, 7, 8, 9].as_ref()));
assert_eq!(iter.next(), None);

Examples found in repository

src/polygon_mesh.rs (line 70)

    pub fn face_iter(&self) -> impl Iterator<Item = &[V]> { self.faces.face_iter() }

src/obj.rs (line 106)

    fn write<W: Write>(&self, writer: &mut W) -> Result<()> {
        for face in self.face_iter() {
            writer.write_all(b"f")?;
            for v in face {
                writer.write_all(b" ")?;
                v.write(writer)?;
            }
            writer.write_all(b"\n")?;
        }
        Ok(())
    }

src/faces.rs (line 272)

    pub(super) fn is_compatible(&self, attrs: &impl Attributes<V>) -> Result<(), Error<V>>
    where V: std::fmt::Debug {
        self.face_iter()
            .flatten()
            .try_for_each(|v| match attrs.get(*v) {
                Some(_) => Ok(()),
                None => Err(Error::OutOfRange(*v)),
            })
    }

    /// Returns iterator with triangulation faces
    ///
    /// # Examples
    /// ```
    /// use truck_polymesh::*;
    /// let slice: &[&[usize]] = &[
    ///     &[0, 1, 2],
    ///     &[0, 4, 5, 1],
    ///     &[1, 2, 6, 7, 8, 9],
    ///     &[1, 2, 4, 3],
    ///     &[0, 2, 3],
    /// ];
    /// let faces = Faces::<usize>::from_iter(slice);
    /// let mut iter = faces.triangle_iter();
    /// assert_eq!(iter.len(), 10);
    /// assert_eq!(iter.next(), Some([0, 1, 2]));
    /// assert_eq!(iter.next(), Some([0, 2, 3]));
    /// assert_eq!(iter.next(), Some([0, 4, 5]));
    /// assert_eq!(iter.next(), Some([0, 5, 1]));
    /// assert_eq!(iter.next(), Some([1, 2, 4]));
    /// assert_eq!(iter.next(), Some([1, 4, 3]));
    /// assert_eq!(iter.next(), Some([1, 2, 6]));
    /// assert_eq!(iter.next(), Some([1, 6, 7]));
    /// assert_eq!(iter.next(), Some([1, 7, 8]));
    /// assert_eq!(iter.next(), Some([1, 8, 9]));
    /// assert_eq!(iter.len(), 0);
    /// assert_eq!(iter.next(), None);
    /// ```
    #[inline(always)]
    pub fn triangle_iter(&self) -> TriangleIterator<'_, V> {
        let len = self.face_iter().fold(0, |sum, face| sum + face.len() - 2);
        TriangleIterator {
            tri_faces: self.tri_faces.iter(),
            quad_faces: self.quad_faces.iter(),
            other_faces: self.other_faces.iter(),
            current_face: None,
            current_vertex: 0,
            len,
        }
    }

pub fn face_iter_mut(&mut self) -> impl Iterator<Item = &mut [V]>

Returns the iterator of the slice.

By the internal optimization, this iterator does not runs in the simple order in which they are registered, but runs order: triangle, square, and the others. cf: Faces:face_iter

Examples found in repository

src/faces.rs (line 347)

    fn invert(&mut self) { self.face_iter_mut().for_each(|f| f.reverse()); }

src/polygon_mesh.rs (line 78)

    pub fn face_iter_mut(&mut self) -> impl Iterator<Item = &mut [V]> { self.faces.face_iter_mut() }
    /// Creates an editor that performs boundary checking on dropped.
    #[inline(always)]
    pub fn editor(&mut self) -> PolygonMeshEditor<'_, V, A> {
        PolygonMeshEditor {
            attributes: &mut self.attributes,
            faces: &mut self.faces,
            bound_check: true,
        }
    }
    /// Creates an editor that does NOT perform boundary checking on dropped.
    #[inline(always)]
    pub fn uncheck_editor(&mut self) -> PolygonMeshEditor<'_, V, A> {
        PolygonMeshEditor {
            attributes: &mut self.attributes,
            faces: &mut self.faces,
            bound_check: false,
        }
    }
    /// Creates an editor that performs boundary checking on dropped ONLY in debug build.
    #[inline(always)]
    pub fn debug_editor(&mut self) -> PolygonMeshEditor<'_, V, A> {
        PolygonMeshEditor {
            attributes: &mut self.attributes,
            faces: &mut self.faces,
            bound_check: cfg!(debug_assertions),
        }
    }
}

impl PolygonMesh {
    /// Returns polygonmesh merged `self` and `mesh`.
    pub fn merge(&mut self, mut mesh: PolygonMesh) {
        let n_pos = self.positions().len();
        let n_uv = self.uv_coords().len();
        let n_nor = self.normals().len();
        mesh.faces.face_iter_mut().for_each(move |face| {
            face.iter_mut().for_each(|v| {
                v.pos += n_pos;
                v.uv = v.uv.map(|uv| uv + n_uv);
                v.nor = v.nor.map(|nor| nor + n_nor);
            })
        });
        self.attributes.positions.extend(mesh.attributes.positions);
        self.attributes.uv_coords.extend(mesh.attributes.uv_coords);
        self.attributes.normals.extend(mesh.attributes.normals);
        self.faces.naive_concat(mesh.faces);
    }

pub fn is_empty(&self) -> bool

Returns true if the faces is empty.

pub fn len(&self) -> usize

Returns the number of faces.

Examples found in repository

src/faces.rs (line 253)

    pub fn is_empty(&self) -> bool { self.len() == 0 }

pub fn naive_concat(&mut self, other: Self)

Merges other into self.

Examples found in repository

src/polygon_mesh.rs (line 124)

    pub fn merge(&mut self, mut mesh: PolygonMesh) {
        let n_pos = self.positions().len();
        let n_uv = self.uv_coords().len();
        let n_nor = self.normals().len();
        mesh.faces.face_iter_mut().for_each(move |face| {
            face.iter_mut().for_each(|v| {
                v.pos += n_pos;
                v.uv = v.uv.map(|uv| uv + n_uv);
                v.nor = v.nor.map(|nor| nor + n_nor);
            })
        });
        self.attributes.positions.extend(mesh.attributes.positions);
        self.attributes.uv_coords.extend(mesh.attributes.uv_coords);
        self.attributes.normals.extend(mesh.attributes.normals);
        self.faces.naive_concat(mesh.faces);
    }

pub fn triangle_iter(&self) -> TriangleIterator<'_, V>

Returns iterator with triangulation faces

Examples

use truck_polymesh::*;
let slice: &[&[usize]] = &[
    &[0, 1, 2],
    &[0, 4, 5, 1],
    &[1, 2, 6, 7, 8, 9],
    &[1, 2, 4, 3],
    &[0, 2, 3],
];
let faces = Faces::<usize>::from_iter(slice);
let mut iter = faces.triangle_iter();
assert_eq!(iter.len(), 10);
assert_eq!(iter.next(), Some([0, 1, 2]));
assert_eq!(iter.next(), Some([0, 2, 3]));
assert_eq!(iter.next(), Some([0, 4, 5]));
assert_eq!(iter.next(), Some([0, 5, 1]));
assert_eq!(iter.next(), Some([1, 2, 4]));
assert_eq!(iter.next(), Some([1, 4, 3]));
assert_eq!(iter.next(), Some([1, 2, 6]));
assert_eq!(iter.next(), Some([1, 6, 7]));
assert_eq!(iter.next(), Some([1, 7, 8]));
assert_eq!(iter.next(), Some([1, 8, 9]));
assert_eq!(iter.len(), 0);
assert_eq!(iter.next(), None);

Examples found in repository

src/stl.rs (line 269)

    fn into_iter(self) -> Self::IntoIter {
        let iter = self.faces().triangle_iter();
        Self::IntoIter {
            positions: self.positions(),
            len: iter.len(),
            faces: iter,
        }
    }

Trait Implementations

impl<V: Clone> Clone for Faces<V>

fn clone(&self) -> Faces<V>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Debug> Debug for Faces<V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V> Default for Faces<V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, V> Deserialize<'de> for Faces<V>where
    V: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: AsRef<[usize]>> FromIterator<S> for Faces<usize>

fn from_iter<I: IntoIterator<Item = S>>(iter: I) -> Faces<usize>

Creates a value from an iterator.

impl<T: AsVertexSlice> FromIterator<T> for Faces

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Faces

Creates a value from an iterator.

impl<V> Index<usize> for Faces<V>

type Output = [V]

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Faces

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<V: Copy> Invertible for Faces<V>

fn invert(&mut self)

Inverts self

fn inverse(&self) -> Self

Returns the inverse.

impl<V: PartialEq> PartialEq<Faces<V>> for Faces<V>

fn eq(&self, other: &Faces<V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> Serialize for Faces<V>where
    V: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V: Eq> Eq for Faces<V>

impl<V> StructuralEq for Faces<V>

impl<V> StructuralPartialEq for Faces<V>