pub fn approx(&self, tolerance: f64, out: &mut Vec<Point<3>>) {
        match self {
            Self::Circle(circle) => circle.approx(tolerance, out),
            Self::Line(Line { a, b }) => out.extend([*a, *b]),
        }
    }
/// Compute an approximation of the curve
///
/// `tolerance` defines how far the approximation is allowed to deviate from
/// the actual edge.
///
/// # Implementation Note
///
/// This only works as it is, because edges are severely limited and don't
/// define which section of the curve they inhabit. Once they do that, we
/// need an `approximate_between(a, b)` method instead, where `a` and `b`
/// are the vertices that bound the edge on the curve.
///
/// The `approx` methods of the curves then need to make sure to return
/// those exact vertices as part of the approximation, and not accidentally
/// compute some almost but not quite identical points for those vertices
/// instead.
Compute an approximation of the curve
`tolerance` defines how far the approximation is allowed to deviate from
the actual edge.
Compute an approximation of the curve ` tolerance ` defines how far the approximation is allowed to deviate from the actual edge .
pub fn approx(&self, tolerance: f64, out: &mut Vec<Point<3>>) {
        match self {
            Self::Circle(circle) => circle.approx(tolerance, out),
            Self::Line(Line { a, b }) => out.extend([*a, *b]),
        }
    }
pub fn approx ( & self , tolerance : f64 , out : & mut Vec < Point < 3 > > ) { match self { Self :: Circle ( circle ) => circle . approx ( tolerance , out ) , Self :: Line ( Line { a , b } ) => out . extend ( [ * a , * b ] ) , } }
Compute an approximation of the curve
`tolerance` defines how far the approximation is allowed to deviate from
the actual edge.
Compute an approximation of the curve ` tolerance ` defines how far the approximation is allowed to deviate from the actual edge .
&self
tolerance
f64
out
&mut Vec<Point<3>>
implementation note
This only works as it is, because edges are severely limited and don't
define which section of the curve they inhabit. Once they do that, we
need an `approximate_between(a, b)` method instead, where `a` and `b`
are the vertices that bound the edge on the curve.

The `approx` methods of the curves then need to make sure to return
those exact vertices as part of the approximation, and not accidentally
compute some almost but not quite identical points for those vertices
instead.
This only works as it is because edges are severely limited and don ' t define which section of the curve they inhabit . Once they do that we need an ` approximate_between ( a b ) ` method instead where ` a ` and ` b ` are the vertices that bound the edge on the curve . The ` approx ` methods of the curves then need to make sure to return those exact vertices as part of the approximation and not accidentally compute some almost but not quite identical points for those vertices instead .