Struct truck_meshalgo::rexport_polymesh::PolygonMesh

pub struct PolygonMesh<V = StandardVertex, A = StandardAttributes> { /* private fields */ }

Polygon mesh

The polygon data is held in a method compliant with wavefront obj. Position, uv (texture) coordinates, and normal vectors are held in separate arrays, and each face vertex accesses those values by an indices triple.

Implementations

impl<V, A> PolygonMesh<V, A>where
    V: Copy + Hash + Debug + Eq,
    A: Attributes<V>,

pub fn expands<T>(
    &self,
    contraction: impl Fn(<A as Attributes<V>>::Output) -> T
) -> PolygonMesh<usize, Vec<T, Global>>where
    T: Copy,

Contract attributes and expand polygon.

Examples

use truck_polymesh::*;
let polygon = PolygonMesh::new(
    StandardAttributes {
        positions: vec![
            Point3::new(0.0, 0.0, 0.0),
            Point3::new(1.0, 0.0, 0.0),
            Point3::new(0.0, 1.0, 0.0),
            Point3::new(1.0, 1.0, 0.0),
        ],
        normals: vec![
            Vector3::new(0.0, 0.0, 1.0),
            Vector3::new(0.0, 0.0, -1.0),
        ],
        ..Default::default()
    },
    Faces::from_iter(&[
        &[(0, None, Some(0)), (1, None, Some(0)), (2, None, Some(0))],
        &[(3, None, Some(1)), (1, None, Some(1)), (2, None, Some(1))],
    ])
);
let expands = polygon.expands(|attr| (attr.position, attr.normal.unwrap()));
assert_eq!(
    expands,
    PolygonMesh::<usize, Vec<(Point3, Vector3)>>::new(
        vec![
           (Point3::new(0.0, 0.0, 0.0), Vector3::new(0.0, 0.0, 1.0)),
           (Point3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 0.0, 1.0)),
           (Point3::new(0.0, 1.0, 0.0), Vector3::new(0.0, 0.0, 1.0)),
           (Point3::new(1.0, 1.0, 0.0), Vector3::new(0.0, 0.0, -1.0)),
           (Point3::new(1.0, 0.0, 0.0), Vector3::new(0.0, 0.0, -1.0)),
           (Point3::new(0.0, 1.0, 0.0), Vector3::new(0.0, 0.0, -1.0)),
        ],
        Faces::from_iter(&[[0, 1, 2], [3, 4, 5]]),
    )
);

impl<V, A> PolygonMesh<V, A>where
    V: Copy + Debug,
    A: Attributes<V>,

pub fn new(attributes: A, faces: Faces<V>) -> PolygonMesh<V, A>

complete constructor

Panics

Panic occurs if there is an index is out of range.

Remarks

This method does not check whether the normal is normalized or not.

pub fn try_new(
    attributes: A,
    faces: Faces<V>
) -> Result<PolygonMesh<V, A>, Error<V>>

complete constructor

Errors

Returns Error::OutOfRange if there is an index is out of range.

Remarks

This method does not check whether the normal is normalized or not.

pub const fn new_unchecked(attributes: A, faces: Faces<V>) -> PolygonMesh<V, A>

constructor without boundary check

pub fn debug_new(attributes: A, faces: Faces<V>) -> PolygonMesh<V, A>

constructor, boundary check is acrivated only in debug mode.

pub const fn attributes(&self) -> &A

Returns attributes

pub const fn faces(&self) -> &Faces<V>

Returns the faces of the polygon.

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

Returns the vector of all triangles of the polygon.

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

Returns the vector of all quadrangles.

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

Returns the vector 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. cf: Faces::face_iter

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

pub fn editor(&mut self) -> PolygonMeshEditor<'_, V, A>

Creates an editor that performs boundary checking on dropped.

pub fn uncheck_editor(&mut self) -> PolygonMeshEditor<'_, V, A>

Creates an editor that does NOT perform boundary checking on dropped.

pub fn debug_editor(&mut self) -> PolygonMeshEditor<'_, V, A>

Creates an editor that performs boundary checking on dropped ONLY in debug build.

impl PolygonMesh<StandardVertex, StandardAttributes>

pub fn merge(&mut self, mesh: PolygonMesh<StandardVertex, StandardAttributes>)

Returns polygonmesh merged self and mesh.

pub fn bounding_box(&self) -> BoundingBox<Point3<f64>>

Creates the bounding box of the polygon mesh.

impl PolygonMesh<StandardVertex, StandardAttributes>

pub const fn positions(&self) -> &Vec<Point3<f64>, Global>

Returns the vector of all positions.

pub fn positions_mut(&mut self) -> &mut [Point3<f64>]

Returns the mutable slice of all positions.

pub fn push_position(&mut self, position: Point3<f64>)

Adds a position.

pub fn extend_positions<I>(&mut self, iter: I)where
    I: IntoIterator<Item = Point3<f64>>,

Extend positions by iterator.

pub const fn uv_coords(&self) -> &Vec<Vector2<f64>, Global>

Returns the vector of all uv (texture) coordinates.

pub fn uv_coords_mut(&mut self) -> &mut [Vector2<f64>]

Returns the mutable slice of all uv (texture) coordinates.

pub fn push_uv_coord(&mut self, uv_coord: Vector2<f64>)

Adds a uv (texture) coordinate.

pub fn extend_uv_coords<I>(&mut self, iter: I)where
    I: IntoIterator<Item = Vector2<f64>>,

Extend uv (texture) coordinates by iterator.

pub const fn normals(&self) -> &Vec<Vector3<f64>, Global>

Returns the vector of all normals.

pub fn normals_mut(&mut self) -> &mut [Vector3<f64>]

Returns the mutable slice of all normals.

pub fn extend_normals<I>(&mut self, iter: I)where
    I: IntoIterator<Item = Vector3<f64>>,

Extend normals by iterator

Trait Implementations

impl<V, A> Clone for PolygonMesh<V, A>where
    V: Clone,
    A: Clone,

fn clone(&self) -> PolygonMesh<V, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Collision for PolygonMesh

fn collide_with(&self, other: &PolygonMesh) -> Option<(Point3, Point3)>

If self and other collide, then returns only one interference line. Otherwise, returns None.

fn extract_interference(&self, other: &PolygonMesh) -> Vec<(Point3, Point3)>

Extract all interference lines between self and other.

impl<V, A> Debug for PolygonMesh<V, A>where
    V: Debug,
    A: Debug,

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

Formats the value using the given formatter.

impl<V, A> Default for PolygonMesh<V, A>where
    A: Default,

fn default() -> PolygonMesh<V, A>

Returns the “default value” for a type.

impl<'de, V, A> Deserialize<'de> for PolygonMesh<V, A>where
    V: Copy + Debug + Deserialize<'de>,
    A: Attributes<V> + Deserialize<'de>,

fn deserialize<D>(
    deserializer: D
) -> Result<PolygonMesh<V, A>, <D as Deserializer<'de>>::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromIterator<STLFace> for PolygonMesh<StandardVertex, StandardAttributes>

fn from_iter<I>(iter: I) -> PolygonMesh<StandardVertex, StandardAttributes>where
    I: IntoIterator<Item = STLFace>,

Creates a value from an iterator.

impl IncludingPointInDomain for PolygonMesh

fn signed_crossing_faces(&self, point: Point3, ray_direction: Vector3) -> isize

Count signed number of faces crossing ray with origin point and direction ray_direction. Counter increase if the dot product of the ray and the normal of a face is positive, and decrease if it is negative.

fn inside(&self, point: Point3) -> bool

whether point is in a domain rounded by a closed polygon.

impl<'a> IntoSTLIterator for &'a PolygonMesh<StandardVertex, StandardAttributes>

type IntoIter = PolygonMeshSTLFaceIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(
    self
) -> <&'a PolygonMesh<StandardVertex, StandardAttributes> as IntoSTLIterator>::IntoIter

Creates an iterator from a value.

impl Invertible for PolygonMesh<StandardVertex, StandardAttributes>

fn invert(&mut self)

Inverts self

fn inverse(&self) -> PolygonMesh<StandardVertex, StandardAttributes>

Returns the inverse.

impl NormalFilters for PolygonMesh

fn normalize_normals(&mut self) -> &mut Self

Normalize all normals and assign None to the nor index of the vertices that has irregular normals.

fn make_face_compatible_to_normal(&mut self) -> &mut Self

Makes the orientation of faces compatible to the normal vectors.

fn make_normal_compatible_to_face(&mut self) -> &mut Self

Makes the orientation of faces compatible to the normal vectors.

fn add_naive_normals(&mut self, overwrite: bool) -> &mut Self

Adds face normals to each vertices.

fn add_smooth_normals(&mut self, tol_ang: f64, overwrite: bool) -> &mut Self

add the smooth normal vectors to the mesh.

impl OptimizingFilter for PolygonMesh

fn remove_unused_attrs(&mut self) -> &mut Self

remove all unused position, texture coordinates, and normal vectors.

fn remove_degenerate_faces(&mut self) -> &mut Self

Removes degenerate polygons.

fn put_together_same_attrs(&mut self) -> &mut Self

Gives the same indices to the same positions, texture coordinate, and normal vectors, respectively.

impl<V, A> PartialEq<PolygonMesh<V, A>> for PolygonMesh<V, A>where
    V: PartialEq<V>,
    A: PartialEq<A>,

fn eq(&self, other: &PolygonMesh<V, A>) -> 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, A> Serialize for PolygonMesh<V, A>where
    V: Serialize,
    A: Serialize,

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

Serialize this value into the given Serde serializer.

impl Splitting for PolygonMesh

fn create_mesh_by_face_indices(&self, indices: &[usize]) -> PolygonMesh

Creates a sub mesh by the face indices.

fn extract_planes(&self, tol: f64) -> (Vec<usize>, Vec<usize>)

Extracts polygons such that there exists its normal is the same as its face normal.

fn components(&self, use_normal: bool) -> Vec<Vec<usize>>

Splits into the components.

impl StructuringFilter for PolygonMesh

fn triangulate(&mut self) -> &mut Self

triangulate all n-gons

fn quadrangulate(&mut self, plane_tol: f64, score_tol: f64) -> &mut Self

join two triangles into one quadrangle.

impl Subdivision for PolygonMesh

fn loop_subdivision(&mut self) -> &mut Self

Extended Loop method

impl Topology for PolygonMesh

fn extract_boundaries(&self) -> Vec<Vec<usize>>

Returns a vector of all boundaries as line strip.

fn shell_condition(&self) -> ShellCondition

Determines the shell conditions: non-regular, regular, oriented, or closed.
The complexity increases in proportion to the number of edges.

impl WithPointCloud for PolygonMesh

fn is_clung_to_by(&self, point_cloud: &[Point3], tol: f64) -> bool

Whether all faces of the polygon mesh self has intersection with the neighborhood of point_cloud.

fn collide_with_neiborhood_of(&self, point_cloud: &[Point3], tol: f64) -> bool

Whether the polygon mesh self and point_cloud collides.

fn neighborhood_include(&self, point_cloud: &[Point3], tol: f64) -> bool

Whether the neighborhood of the polygon mesh self includes point_cloud.

impl<V, A> Eq for PolygonMesh<V, A>where
    V: Eq,
    A: Eq,

impl<V, A> StructuralEq for PolygonMesh<V, A>

impl<V, A> StructuralPartialEq for PolygonMesh<V, A>