Method is_collapse_ok

splashsurf_lib/src/halfedge_mesh.rs:204–256

Checks if the collapse of the given half-edge is topologically legal

(&self, half_edge: HalfEdge)

    /// Checks if the collapse of the given half-edge is topologically legal
    pub fn is_collapse_ok(&self, half_edge: HalfEdge) -> Result<(), IllegalHalfEdgeCollapse> {
        // Based on PMP library:
        // https://github.com/pmp-library/pmp-library/blob/86099e4e274c310d23e8c46c4829f881242814d3/src/pmp/SurfaceMesh.cpp#L755

        let v0v1 = half_edge;
        let v1v0 = self.opposite(v0v1);

        let v0 = v1v0.to; // From vertex
        let v1 = v0v1.to; // To vertex

        // Checks if edges to opposite vertex of half-edge are boundary edges and returns opposite vertex
        let check_opposite_vertex =
            |he: HalfEdge| -> Result<Option<usize>, IllegalHalfEdgeCollapse> {
                if !he.is_boundary() {
                    let h1 = self.next(he);
                    let h2 = self.next(h1);

                    if self.opposite(h1).is_boundary() && self.opposite(h2).is_boundary() {
                        return Err(IllegalHalfEdgeCollapse::BoundaryCollapse);
                    }

                    // Return the opposite vertex
                    Ok(Some(h1.to))
                } else {
                    Ok(None)
                }
            };

        // Notation:
        //   v_pos -> vertex opposite to the half-edge to collapse (v0v1)
        //   v_neg -> vertex opposite to the opposite half-edge to collapse (v1v0)
        let v_pos = check_opposite_vertex(v0v1)?;
        let v_neg = check_opposite_vertex(v1v0)?;

        if v_pos.is_none() || v_neg.is_none() {
            return Err(IllegalHalfEdgeCollapse::FacelessEdge);
        }

        // Test intersection of the one-rings of v0 and v1
        for &he in &self.vertex_half_edge_map[v0] {
            let he = &self.half_edges[he];
            let vv = he.to;
            if vv != v1
                && Some(vv) != v_pos
                && Some(vv) != v_neg
                && self.half_edge(vv, v1).is_some()
            {
                return Err(IllegalHalfEdgeCollapse::IntersectionOfOneRing);
            }
        }

        Ok(())
    }

    pub fn try_half_edge_collapse(
        &mut self,