pub fn approx(&self, tolerance: f64) -> Approx {
        let mut vertices = Vec::new();
        let mut segments = Vec::new();

        for cycle in &self.cycles {
            let approx = cycle.approx(tolerance);

            vertices.extend(approx.vertices);
            segments.extend(approx.segments);
        }

        Approx { vertices, segments }
    }
/// Compute an approximation of the edges
///
/// `tolerance` defines how far the approximation is allowed to deviate from
/// the actual edges.
///
/// # Implementation note
///
/// As of this writing, each edge is approximated multiple times, for the
/// triangulation of each face that it is adjacent to. This might not be
/// desirable, for the following reasons:
///
/// 1. Efficiency: Approximating an edge once and caching the result might
///    realize a performance gain.
/// 2. Correctness: It is conceivable that the same edge is approximated
///    differently for each of its neighboring faces, if the algorithm used
///    is not fully deterministic. If that were to happen, this would result
///    in a triangle mesh where the triangles don't connect.
///
/// Only approximating an edge once, and then referring to that
/// approximation from then on where needed, would take care of these two
/// problems.
Compute an approximation of the edges
`tolerance` defines how far the approximation is allowed to deviate from
the actual edges.
Compute an approximation of the edges ` tolerance ` defines how far the approximation is allowed to deviate from the actual edges .
pub fn approx(&self, tolerance: f64) -> Approx {
        let mut vertices = Vec::new();
        let mut segments = Vec::new();
        for cycle in &self.cycles {
            let approx = cycle.approx(tolerance);
            vertices.extend(approx.vertices);
            segments.extend(approx.segments);
        }
        Approx { vertices, segments }
    }
pub fn approx ( & self , tolerance : f64 ) -> Approx { let mut vertices = Vec :: new ( ) ; let mut segments = Vec :: new ( ) ; for cycle in & self . cycles { let approx = cycle . approx ( tolerance ) ; vertices . extend ( approx . vertices ) ; segments . extend ( approx . segments ) ; } Approx { vertices , segments } }
Compute an approximation of the edges
`tolerance` defines how far the approximation is allowed to deviate from
the actual edges.
Compute an approximation of the edges ` tolerance ` defines how far the approximation is allowed to deviate from the actual edges .
&self
tolerance
f64
implementation note
As of this writing, each edge is approximated multiple times, for the
triangulation of each face that it is adjacent to. This might not be
desirable, for the following reasons.

1. Efficiency: Approximating an edge once and caching the result might
realize a performance gain.
2. Correctness: It is conceivable that the same edge is approximated
differently for each of its neighboring faces, if the algorithm used
is not fully deterministic. If that were to happen, this would result
in a triangle mesh where the triangles don't connect.

Only approximating an edge once, and then referring to that
approximation from then on where needed, would take care of these two
problems.
As of this writing each edge is approximated multiple times for the triangulation of each face that it is adjacent to . This might not be desirable for the following reasons . 1 . Efficiency : Approximating an edge once and caching the result might realize a performance gain . 2 . Correctness : It is conceivable that the same edge is approximated differently for each of its neighboring faces if the algorithm used is not fully deterministic . If that were to happen this would result in a triangle mesh where the triangles don ' t connect . Only approximating an edge once and then referring to that approximation from then on where needed would take care of these two problems .