Struct rust_3d::SearchableMesh

pub struct SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3>,
    IC: IsIndexContainer,  { /* fields omitted */ }

SearchableMesh, transforms IsMesh to IsSearchableMesh

Implementations

impl<M, T, IC> SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3>,
    IC: IsIndexContainer, 

pub fn new(mesh: M) -> Self

Creates a new SearchableMesh3D from an IsMesh3D This only stays valid if IMesh3D is not changed after creation The mesh must be manifold

pub fn ensure_face_id(&self, id: FId) -> Result<()>

Fails if the vertex ID is out of bounds

pub fn mesh(&self) -> &M

Returns a reference to the held mesh

Trait Implementations

impl<M, T, IC> AsRef<M> for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3>,
    IC: IsIndexContainer, 

fn as_ref(&self) -> &M

Performs the conversion.

impl<M: Clone, T: Clone, IC: Clone> Clone for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3>,
    IC: IsIndexContainer, 

fn clone(&self) -> SearchableMesh<M, T, IC>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M, T, IC> From<(M, HalfEdge<IC>)> for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3>,
    IC: IsIndexContainer, 

fn from(me: (M, HalfEdge<IC>)) -> Self

Performs the conversion.

impl<M, T, IC> HasBoundingBox3DMaybe for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3> + HasBoundingBox3DMaybe,
    IC: IsIndexContainer, 

fn bounding_box_maybe(&self) -> Result<BoundingBox3D>

Should return the bounding box if it can be calculated

impl<M, T, IC> HasCenterOfGravity3D for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3> + HasCenterOfGravity3D,
    IC: IsIndexContainer, 

fn center_of_gravity(&self) -> Result<Point3D>

Should return the center of gravity

impl<M, T, IC> Into<(M, HalfEdge<IC>)> for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3>,
    IC: IsIndexContainer, 

fn into(self) -> (M, HalfEdge<IC>)

Performs the conversion.

impl<M, T, IC> IsMesh<T, Face3> for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3>,
    IC: IsIndexContainer, 

fn num_faces(&self) -> usize

Should return the number of faces within the mesh

fn num_vertices(&self) -> usize

Should return the number of vertices within the mesh

fn face_vertex_ids(&self, faceid: FId) -> Result<Face3>

Should return the ids of vertices of the given face

fn face_vertices(&self, faceid: FId) -> Result<[T; 3]>

Should return the vertices of the given face

fn vertex(&self, vertexid: VId) -> Result<T>

Should return the vertex with the given id

impl<M, T, IC> IsScalable for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3> + IsScalable,
    IC: IsIndexContainer, 

fn scale(&mut self, factor: Positive)

Should scale by the given factor. 0.5 -> half size, 2.0 double the size without moving the position/center

impl<M, T, IC> IsSearchableMesh<T, Face3> for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3>,
    IC: IsIndexContainer, 

fn num_edges(&self) -> usize

Returns the number of edges within the mesh

fn edges_of_face(&self, faceid: FId) -> Result<(EId, EId, EId)>

Should return the edge ids of the given face. Error if id invalid

fn edges_originating_from_vertex(
    &self,
    vertexid: VId,
    result: &mut Vec<EId>
) -> Result<()>

Should append the edges originating at the given vertex (pointing away / having the vertex as tail). Error if id invalid

fn edges_ending_at_vertex(
    &self,
    vertexid: VId,
    cache: &mut Vec<EId>,
    result: &mut Vec<EId>
) -> Result<()>

Should append the edges ending at the given vertex (pointing to / having the vertex as head). Error if id invalid cache can be any Vec and can be used to store intermediate results avoiding allocations

fn edges_of_vertex(
    &self,
    vertexid: VId,
    cache: &mut Vec<EId>,
    result: &mut Vec<EId>
) -> Result<()>

Should append the edges connecting with the vertex. Error if id invalid cache can be any Vec and can be used to store intermediate results avoiding allocations

fn edge_tail(&self, edgeid: EId) -> Result<VId>

Should return the vertex id of the edge's tail. Error if id invalid

fn edge_head(&self, edgeid: EId) -> Result<VId>

Should return the vertex id of the edge's head. Error if id invalid

fn edge_next(&self, edgeid: EId) -> Result<EId>

Should return the edge id of the next edge. Error if id invalid

fn edge_prev(&self, edgeid: EId) -> Result<EId>

Should return the edge id of the previous edge. Error if id invalid

fn edge_twin(&self, edgeid: EId) -> Result<Option<EId>>

Should return the edge id of the twin edge. Error if id invalid, None if there is none

fn edge_face(&self, edgeid: EId) -> Result<FId>

Should return the face id of the edges face. Error if id invalid

fn faces_of_vertex(
    &self,
    vertexid: VId,
    cache: &mut Vec<EId>,
    result: &mut Vec<FId>
) -> Result<()>

Appends faces a vertex is part of. Error if id invalid cache can be any Vec

fn face_edge_neighbours(&self, faceid: FId, result: &mut Vec<FId>) -> Result<()>

Appends the neighbouring faces of the given face which share the same edges. Error if id invalid

fn face_vertex_neighbours(
    &self,
    faceid: FId,
    cache: &mut Vec<EId>,
    result: &mut Vec<FId>
) -> Result<()>

Appends the neighbouring faces of the given face which share the same vertices. Sorts and dedups the result. Error if id invalid cache can be any Vec

impl<M, T, IC> IsVertexEditableMesh<T, Face3> for SearchableMesh<M, T, IC> where
    M: IsMesh<T, Face3> + IsVertexEditableMesh<T, Face3>,
    T: IsEditable3D + IsBuildable3D + Clone,
    IC: IsIndexContainer, 

fn add_vertex(&mut self, vertex: T) -> VId

Should add a vertex to the end and return its id

fn change_vertex(&mut self, vid: VId, vertex: T) -> Result<()>

Should change vertex at vId to the given vertex returning an error on failure

fn reserve_vertices(&mut self, n: usize)

Should reserve space for n additional vertices