Struct fj_kernel::objects::Vertex

pub struct Vertex { /* private fields */ }

A vertex

Vertex is defined in terms of a 1-dimensional position on a curve. If you need the 3D position of a vertex, you can use Vertex::global_form, to get access of the global form of a vertex (GlobalVertex).

Implementations

impl Vertex

pub fn new(
    position: impl Into<Point<1>>,
    curve: Handle<Curve>,
    surface_form: Handle<SurfaceVertex>
) -> Self

Construct an instance of Vertex

Examples found in repository

src/partial/objects/vertex.rs (line 51)

    fn build(mut self, objects: &mut Service<Objects>) -> Self::Full {
        let position = self
            .position
            .expect("Can't build `Vertex` without position");
        let curve = self.curve.build(objects);

        // Infer surface position, if not available.
        if self.surface_form.read().position.is_none() {
            self.surface_form.write().position =
                Some(curve.path().point_from_path_coords(position));
        }

        let surface_form = self.surface_form.build(objects);

        Vertex::new(position, curve, surface_form)
    }

src/algorithms/transform/vertex.rs (line 30)

    fn transform_with_cache(
        self,
        transform: &Transform,
        objects: &mut Service<Objects>,
        cache: &mut TransformCache,
    ) -> Self {
        // Don't need to transform position, as that is defined in curve
        // coordinates and thus transforming the curve takes care of it.
        let position = self.position();

        let curve = self
            .curve()
            .clone()
            .transform_with_cache(transform, objects, cache);
        let surface_form = self
            .surface_form()
            .clone()
            .transform_with_cache(transform, objects, cache);

        Self::new(position, curve, surface_form)
    }

src/algorithms/sweep/vertex.rs (lines 109-113)

    fn sweep_with_cache(
        self,
        path: impl Into<Vector<3>>,
        cache: &mut SweepCache,
        objects: &mut Service<Objects>,
    ) -> Self::Swept {
        let (vertex, surface) = self;
        let path = path.into();

        // The result of sweeping a `Vertex` is an `Edge`. Seems
        // straight-forward at first, but there are some subtleties we need to
        // understand:
        //
        // 1. To create an `Edge`, we need the `Curve` that defines it. A
        //    `Curve` is defined in a `Surface`, and we're going to need that to
        //    create the `Curve`. Which is why this `Sweep` implementation is
        //    for `(Vertex, Surface)`, and not just for `Vertex`.
        // 2. Please note that, while the output `Edge` has two vertices, our
        //    input `Vertex` is not one of them! It can't be, unless the `Curve`
        //    of the output `Edge` happens to be the same `Curve` that the input
        //    `Vertex` is defined on. That would be an edge case that probably
        //    can't result in anything valid, and we're going to ignore it for
        //    now.
        // 3. This means, we have to compute everything that defines the
        //    output `Edge`: The `Curve`, the vertices, and the `GlobalCurve`.
        //
        // Before we get to that though, let's make sure that whoever called
        // this didn't give us bad input.

        // So, we're supposed to create the `Edge` by sweeping a `Vertex` using
        // `path`. Unless `path` is identical to the path that created the
        // `Surface`, this doesn't make any sense. Let's make sure this
        // requirement is met.
        //
        // Further, the `Curve` that was swept to create the `Surface` needs to
        // be the same `Curve` that the input `Vertex` is defined on. If it's
        // not, we have no way of knowing the surface coordinates of the input
        // `Vertex` on the `Surface`, and we're going to need to do that further
        // down. There's no way to check for that, unfortunately.
        assert_eq!(path, surface.geometry().v);

        // With that out of the way, let's start by creating the `GlobalEdge`,
        // as that is the most straight-forward part of this operations, and
        // we're going to need it soon anyway.
        let (edge_global, vertices_global) = vertex
            .global_form()
            .clone()
            .sweep_with_cache(path, cache, objects);

        // Next, let's compute the surface coordinates of the two vertices of
        // the output `Edge`, as we're going to need these for the rest of this
        // operation.
        //
        // They both share a u-coordinate, which is the t-coordinate of our
        // input `Vertex`. Remember, we validated above, that the `Curve` of the
        // `Surface` and the curve of the input `Vertex` are the same, so we can
        // do that.
        //
        // Now remember what we also validated above: That `path`, which we're
        // using to create the output `Edge`, also created the `Surface`, and
        // thereby defined its coordinate system. That makes the v-coordinates
        // straight-forward: The start of the edge is at zero, the end is at
        // one.
        let points_surface = [
            Point::from([vertex.position().t, Scalar::ZERO]),
            Point::from([vertex.position().t, Scalar::ONE]),
        ];

        // Armed with those coordinates, creating the `Curve` of the output
        // `Edge` is straight-forward.
        let curve = {
            let (path, _) = SurfacePath::line_from_points(points_surface);

            Curve::new(surface.clone(), path, edge_global.curve().clone())
                .insert(objects)
        };

        let vertices_surface = {
            let [_, position] = points_surface;
            let [_, global_form] = vertices_global;

            [
                vertex.surface_form().clone(),
                SurfaceVertex::new(position, surface, global_form)
                    .insert(objects),
            ]
        };

        // And now the vertices. Again, nothing wild here.
        let vertices = vertices_surface.map(|surface_form| {
            Vertex::new(
                [surface_form.position().v],
                curve.clone(),
                surface_form,
            )
            .insert(objects)
        });

        // And finally, creating the output `Edge` is just a matter of
        // assembling the pieces we've already created.
        HalfEdge::new(vertices, edge_global).insert(objects)
    }

src/algorithms/sweep/edge.rs (lines 79-83)

    fn sweep_with_cache(
        self,
        path: impl Into<Vector<3>>,
        cache: &mut SweepCache,
        objects: &mut Service<Objects>,
    ) -> Self::Swept {
        let (edge, color) = self;
        let path = path.into();

        let surface =
            edge.curve().clone().sweep_with_cache(path, cache, objects);

        // We can't use the edge we're sweeping from as the bottom edge, as that
        // is not defined in the right surface. Let's create a new bottom edge,
        // by swapping the surface of the original.
        let bottom_edge = {
            let vertices = edge.vertices();

            let points_curve_and_surface = vertices.clone().map(|vertex| {
                (vertex.position(), [vertex.position().t, Scalar::ZERO])
            });

            let curve = {
                // Please note that creating a line here is correct, even if the
                // global curve is a circle. Projected into the side surface, it
                // is going to be a line either way.
                let path =
                    SurfacePath::Line(Line::from_points_with_line_coords(
                        points_curve_and_surface,
                    ));

                Curve::new(
                    surface.clone(),
                    path,
                    edge.curve().global_form().clone(),
                )
                .insert(objects)
            };

            let vertices = {
                let points_surface = points_curve_and_surface
                    .map(|(_, point_surface)| point_surface);

                vertices
                    .each_ref_ext()
                    .into_iter_fixed()
                    .zip(points_surface)
                    .collect::<[_; 2]>()
                    .map(|(vertex, point_surface)| {
                        let surface_vertex = SurfaceVertex::new(
                            point_surface,
                            surface.clone(),
                            vertex.global_form().clone(),
                        )
                        .insert(objects);

                        Vertex::new(
                            vertex.position(),
                            curve.clone(),
                            surface_vertex,
                        )
                        .insert(objects)
                    })
            };

            HalfEdge::new(vertices, edge.global_form().clone()).insert(objects)
        };

        let side_edges = bottom_edge.vertices().clone().map(|vertex| {
            (vertex, surface.clone()).sweep_with_cache(path, cache, objects)
        });

        let top_edge = {
            let bottom_vertices = bottom_edge.vertices();

            let surface_vertices = side_edges.clone().map(|edge| {
                let [_, vertex] = edge.vertices();
                vertex.surface_form().clone()
            });

            let points_curve_and_surface =
                bottom_vertices.clone().map(|vertex| {
                    (vertex.position(), [vertex.position().t, Scalar::ONE])
                });

            let curve = {
                let global = bottom_edge
                    .curve()
                    .global_form()
                    .clone()
                    .translate(path, objects);

                // Please note that creating a line here is correct, even if the
                // global curve is a circle. Projected into the side surface, it
                // is going to be a line either way.
                let path =
                    SurfacePath::Line(Line::from_points_with_line_coords(
                        points_curve_and_surface,
                    ));

                Curve::new(surface, path, global).insert(objects)
            };

            let global = GlobalEdge::new(
                curve.global_form().clone(),
                surface_vertices
                    .clone()
                    .map(|surface_vertex| surface_vertex.global_form().clone()),
            )
            .insert(objects);

            let vertices = bottom_vertices
                .each_ref_ext()
                .into_iter_fixed()
                .zip(surface_vertices)
                .collect::<[_; 2]>()
                .map(|(vertex, surface_form)| {
                    Vertex::new(vertex.position(), curve.clone(), surface_form)
                        .insert(objects)
                });

            HalfEdge::new(vertices, global).insert(objects)
        };

        let cycle = {
            let a = bottom_edge;
            let [d, b] = side_edges;
            let c = top_edge;

            let mut edges = [a, b, c, d];

            // Make sure that edges are oriented correctly.
            let mut i = 0;
            while i < edges.len() {
                let j = (i + 1) % edges.len();

                let [_, prev_last] = edges[i].vertices();
                let [next_first, _] = edges[j].vertices();

                // Need to compare surface forms here, as the global forms might
                // be coincident when sweeping circles, despite the vertices
                // being different!
                if prev_last.surface_form().id()
                    != next_first.surface_form().id()
                {
                    edges[j] = edges[j].clone().reverse(objects);
                }

                i += 1;
            }

            Cycle::new(edges).insert(objects)
        };

        let face = PartialFace {
            exterior: Partial::from(cycle),
            color: Some(color),
            ..Default::default()
        };
        face.build(objects).insert(objects)
    }

pub fn position(&self) -> Point<1>

Access the position of the vertex on the curve

Examples found in repository

src/objects/full/edge.rs (line 63)

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let [a, b] = self.vertices().clone().map(|vertex| vertex.position());
        write!(f, "edge from {a:?} to {b:?}")?;
        write!(f, " on {:?}", self.curve().global_form())?;

        Ok(())
    }

src/partial/objects/vertex.rs (line 28)

    fn from_full(vertex: &Self::Full, cache: &mut FullToPartialCache) -> Self {
        Self {
            position: Some(vertex.position()),
            curve: Partial::from_full(vertex.curve().clone(), cache),
            surface_form: Partial::from_full(
                vertex.surface_form().clone(),
                cache,
            ),
        }
    }

src/validate/edge.rs (line 182)

    fn check_vertex_positions(
        half_edge: &HalfEdge,
        config: &ValidationConfig,
    ) -> Result<(), Self> {
        let back_position = half_edge.back().position();
        let front_position = half_edge.front().position();

        let distance = (back_position - front_position).magnitude();

        if distance < config.distinct_min_distance {
            return Err(Self::VerticesAreCoincident {
                back_position,
                front_position,
                distance,
            });
        }

        Ok(())
    }

src/algorithms/intersect/ray_edge.rs (line 28)

    fn intersect(self) -> Option<Self::Intersection> {
        let (ray, edge) = self;

        let line = match edge.curve().path() {
            SurfacePath::Line(line) => line,
            SurfacePath::Circle(_) => {
                todo!("Casting rays against circles is not supported yet")
            }
        };

        let points = edge.vertices().clone().map(|vertex| {
            let point = vertex.position();
            line.point_from_line_coords(point)
        });
        let segment = Segment::from_points(points);

        (ray, &segment).intersect()
    }

src/algorithms/approx/edge.rs (line 26)

    fn approx_with_cache(
        self,
        tolerance: impl Into<Tolerance>,
        cache: &mut Self::Cache,
    ) -> Self::Approximation {
        let [a, b] = self.vertices();
        let boundary = [a, b].map(|vertex| vertex.position());
        let range = RangeOnPath { boundary };

        let first = ApproxPoint::new(
            a.surface_form().position(),
            a.global_form().position(),
        );
        let curve_approx =
            (self.curve(), range).approx_with_cache(tolerance, cache);

        HalfEdgeApprox {
            first,
            curve_approx,
        }
    }

src/algorithms/transform/vertex.rs (line 19)

    fn transform_with_cache(
        self,
        transform: &Transform,
        objects: &mut Service<Objects>,
        cache: &mut TransformCache,
    ) -> Self {
        // Don't need to transform position, as that is defined in curve
        // coordinates and thus transforming the curve takes care of it.
        let position = self.position();

        let curve = self
            .curve()
            .clone()
            .transform_with_cache(transform, objects, cache);
        let surface_form = self
            .surface_form()
            .clone()
            .transform_with_cache(transform, objects, cache);

        Self::new(position, curve, surface_form)
    }

Additional examples can be found in:

• src/validate/vertex.rs
• src/algorithms/intersect/curve_edge.rs
• src/objects/full/cycle.rs
• src/algorithms/sweep/vertex.rs
• src/algorithms/sweep/edge.rs

pub fn curve(&self) -> &Handle<Curve>

Access the curve that the vertex is defined in

Examples found in repository

src/objects/full/edge.rs (line 30)

    pub fn curve(&self) -> &Handle<Curve> {
        let [vertex, _] = self.vertices();
        vertex.curve()
    }

src/iter.rs (line 282)

    fn referenced_objects(&'r self) -> Vec<&'r dyn ObjectIters> {
        vec![
            self.curve() as &dyn ObjectIters,
            self.global_form() as &dyn ObjectIters,
        ]
    }

src/partial/objects/vertex.rs (line 29)

    fn from_full(vertex: &Self::Full, cache: &mut FullToPartialCache) -> Self {
        Self {
            position: Some(vertex.position()),
            curve: Partial::from_full(vertex.curve().clone(), cache),
            surface_form: Partial::from_full(
                vertex.surface_form().clone(),
                cache,
            ),
        }
    }

src/validate/edge.rs (line 116)

    fn check_curve_identity(half_edge: &HalfEdge) -> Result<(), Self> {
        let back_curve = half_edge.back().curve();
        let front_curve = half_edge.front().curve();

        if back_curve.id() != front_curve.id() {
            return Err(Self::CurveMismatch {
                back_curve: back_curve.clone(),
                front_curve: front_curve.clone(),
            });
        }

        Ok(())
    }

src/validate/vertex.rs (line 90)

    fn check_surface_identity(vertex: &Vertex) -> Result<(), Self> {
        let curve_surface = vertex.curve().surface();
        let surface_form_surface = vertex.surface_form().surface();

        if curve_surface.id() != surface_form_surface.id() {
            return Err(Self::SurfaceMismatch {
                curve_surface: curve_surface.clone(),
                surface_form_surface: surface_form_surface.clone(),
            });
        }

        Ok(())
    }

    fn check_position(
        vertex: &Vertex,
        config: &ValidationConfig,
    ) -> Result<(), Self> {
        let curve_position_as_surface = vertex
            .curve()
            .path()
            .point_from_path_coords(vertex.position());
        let surface_position = vertex.surface_form().position();

        let distance = curve_position_as_surface.distance_to(&surface_position);

        if distance > config.identical_max_distance {
            return Err(Self::PositionMismatch {
                vertex: vertex.clone(),
                surface_vertex: vertex.surface_form().clone_object(),
                curve_position_as_surface,
                distance,
            });
        }

        Ok(())
    }

src/algorithms/transform/vertex.rs (line 22)

    fn transform_with_cache(
        self,
        transform: &Transform,
        objects: &mut Service<Objects>,
        cache: &mut TransformCache,
    ) -> Self {
        // Don't need to transform position, as that is defined in curve
        // coordinates and thus transforming the curve takes care of it.
        let position = self.position();

        let curve = self
            .curve()
            .clone()
            .transform_with_cache(transform, objects, cache);
        let surface_form = self
            .surface_form()
            .clone()
            .transform_with_cache(transform, objects, cache);

        Self::new(position, curve, surface_form)
    }

pub fn surface_form(&self) -> &Handle<SurfaceVertex>

Access the surface form of this vertex

Examples found in repository

src/partial/objects/vertex.rs (line 31)

    fn from_full(vertex: &Self::Full, cache: &mut FullToPartialCache) -> Self {
        Self {
            position: Some(vertex.position()),
            curve: Partial::from_full(vertex.curve().clone(), cache),
            surface_form: Partial::from_full(
                vertex.surface_form().clone(),
                cache,
            ),
        }
    }

src/validate/vertex.rs (line 91)

    fn check_surface_identity(vertex: &Vertex) -> Result<(), Self> {
        let curve_surface = vertex.curve().surface();
        let surface_form_surface = vertex.surface_form().surface();

        if curve_surface.id() != surface_form_surface.id() {
            return Err(Self::SurfaceMismatch {
                curve_surface: curve_surface.clone(),
                surface_form_surface: surface_form_surface.clone(),
            });
        }

        Ok(())
    }

    fn check_position(
        vertex: &Vertex,
        config: &ValidationConfig,
    ) -> Result<(), Self> {
        let curve_position_as_surface = vertex
            .curve()
            .path()
            .point_from_path_coords(vertex.position());
        let surface_position = vertex.surface_form().position();

        let distance = curve_position_as_surface.distance_to(&surface_position);

        if distance > config.identical_max_distance {
            return Err(Self::PositionMismatch {
                vertex: vertex.clone(),
                surface_vertex: vertex.surface_form().clone_object(),
                curve_position_as_surface,
                distance,
            });
        }

        Ok(())
    }

src/validate/cycle.rs (line 51)

    fn check_half_edge_connections(cycle: &Cycle) -> Result<(), Self> {
        for (a, b) in cycle.half_edges().circular_tuple_windows() {
            let [_, prev] = a.vertices();
            let [next, _] = b.vertices();

            let prev = prev.surface_form();
            let next = next.surface_form();

            if prev.id() != next.id() {
                return Err(Self::HalfEdgeConnection {
                    prev: prev.clone(),
                    next: next.clone(),
                });
            }
        }

        Ok(())
    }

src/algorithms/approx/edge.rs (line 30)

    fn approx_with_cache(
        self,
        tolerance: impl Into<Tolerance>,
        cache: &mut Self::Cache,
    ) -> Self::Approximation {
        let [a, b] = self.vertices();
        let boundary = [a, b].map(|vertex| vertex.position());
        let range = RangeOnPath { boundary };

        let first = ApproxPoint::new(
            a.surface_form().position(),
            a.global_form().position(),
        );
        let curve_approx =
            (self.curve(), range).approx_with_cache(tolerance, cache);

        HalfEdgeApprox {
            first,
            curve_approx,
        }
    }

src/algorithms/transform/vertex.rs (line 26)

    fn transform_with_cache(
        self,
        transform: &Transform,
        objects: &mut Service<Objects>,
        cache: &mut TransformCache,
    ) -> Self {
        // Don't need to transform position, as that is defined in curve
        // coordinates and thus transforming the curve takes care of it.
        let position = self.position();

        let curve = self
            .curve()
            .clone()
            .transform_with_cache(transform, objects, cache);
        let surface_form = self
            .surface_form()
            .clone()
            .transform_with_cache(transform, objects, cache);

        Self::new(position, curve, surface_form)
    }

src/objects/full/cycle.rs (line 97)

    pub fn winding(&self) -> Winding {
        // The cycle could be made up of one or two circles. If that is the
        // case, the winding of the cycle is determined by the winding of the
        // first circle.
        if self.half_edges.len() < 3 {
            let first = self
                .half_edges()
                .next()
                .expect("Invalid cycle: expected at least one half-edge");

            let [a, b] = first.vertices();
            let edge_direction_positive = a.position() < b.position();

            let circle = match first.curve().path() {
                SurfacePath::Circle(circle) => circle,
                SurfacePath::Line(_) => unreachable!(
                    "Invalid cycle: less than 3 edges, but not all are circles"
                ),
            };
            let cross_positive = circle.a().cross2d(&circle.b()) > Scalar::ZERO;

            if edge_direction_positive == cross_positive {
                return Winding::Ccw;
            } else {
                return Winding::Cw;
            }
        }

        // Now that we got the special case out of the way, we can treat the
        // cycle as a polygon:
        // https://stackoverflow.com/a/1165943

        let mut sum = Scalar::ZERO;

        for [a, b] in self.half_edges.as_slice().array_windows_ext() {
            let [a, b] = [a, b].map(|half_edge| {
                let [vertex, _] = half_edge.vertices();
                vertex.surface_form().position()
            });

            sum += (b.u - a.u) * (b.v + a.v);
        }

        if sum > Scalar::ZERO {
            return Winding::Cw;
        }
        if sum < Scalar::ZERO {
            return Winding::Ccw;
        }

        unreachable!("Encountered invalid cycle: {self:#?}");
    }

Additional examples can be found in:

• src/algorithms/sweep/vertex.rs
• src/algorithms/sweep/edge.rs

pub fn global_form(&self) -> &Handle<GlobalVertex>

Access the global form of this vertex

Examples found in repository

src/iter.rs (line 283)

    fn referenced_objects(&'r self) -> Vec<&'r dyn ObjectIters> {
        vec![
            self.curve() as &dyn ObjectIters,
            self.global_form() as &dyn ObjectIters,
        ]
    }

src/algorithms/approx/edge.rs (line 31)

    fn approx_with_cache(
        self,
        tolerance: impl Into<Tolerance>,
        cache: &mut Self::Cache,
    ) -> Self::Approximation {
        let [a, b] = self.vertices();
        let boundary = [a, b].map(|vertex| vertex.position());
        let range = RangeOnPath { boundary };

        let first = ApproxPoint::new(
            a.surface_form().position(),
            a.global_form().position(),
        );
        let curve_approx =
            (self.curve(), range).approx_with_cache(tolerance, cache);

        HalfEdgeApprox {
            first,
            curve_approx,
        }
    }

src/validate/edge.rs (line 151)

    fn check_global_vertex_identity(half_edge: &HalfEdge) -> Result<(), Self> {
        let global_vertices_from_vertices = {
            let (global_vertices_from_vertices, _) =
                VerticesInNormalizedOrder::new(
                    half_edge
                        .vertices()
                        .each_ref_ext()
                        .map(|vertex| vertex.global_form().clone()),
                );

            global_vertices_from_vertices.access_in_normalized_order()
        };
        let global_vertices_from_global_form = half_edge
            .global_form()
            .vertices()
            .access_in_normalized_order();

        let ids_from_vertices = global_vertices_from_vertices
            .each_ref_ext()
            .map(|global_vertex| global_vertex.id());
        let ids_from_global_form = global_vertices_from_global_form
            .each_ref_ext()
            .map(|global_vertex| global_vertex.id());

        if ids_from_vertices != ids_from_global_form {
            return Err(Self::GlobalVertexMismatch {
                global_vertices_from_vertices,
                global_vertices_from_global_form,
            });
        }

        Ok(())
    }

src/algorithms/sweep/vertex.rs (line 64)

    fn sweep_with_cache(
        self,
        path: impl Into<Vector<3>>,
        cache: &mut SweepCache,
        objects: &mut Service<Objects>,
    ) -> Self::Swept {
        let (vertex, surface) = self;
        let path = path.into();

        // The result of sweeping a `Vertex` is an `Edge`. Seems
        // straight-forward at first, but there are some subtleties we need to
        // understand:
        //
        // 1. To create an `Edge`, we need the `Curve` that defines it. A
        //    `Curve` is defined in a `Surface`, and we're going to need that to
        //    create the `Curve`. Which is why this `Sweep` implementation is
        //    for `(Vertex, Surface)`, and not just for `Vertex`.
        // 2. Please note that, while the output `Edge` has two vertices, our
        //    input `Vertex` is not one of them! It can't be, unless the `Curve`
        //    of the output `Edge` happens to be the same `Curve` that the input
        //    `Vertex` is defined on. That would be an edge case that probably
        //    can't result in anything valid, and we're going to ignore it for
        //    now.
        // 3. This means, we have to compute everything that defines the
        //    output `Edge`: The `Curve`, the vertices, and the `GlobalCurve`.
        //
        // Before we get to that though, let's make sure that whoever called
        // this didn't give us bad input.

        // So, we're supposed to create the `Edge` by sweeping a `Vertex` using
        // `path`. Unless `path` is identical to the path that created the
        // `Surface`, this doesn't make any sense. Let's make sure this
        // requirement is met.
        //
        // Further, the `Curve` that was swept to create the `Surface` needs to
        // be the same `Curve` that the input `Vertex` is defined on. If it's
        // not, we have no way of knowing the surface coordinates of the input
        // `Vertex` on the `Surface`, and we're going to need to do that further
        // down. There's no way to check for that, unfortunately.
        assert_eq!(path, surface.geometry().v);

        // With that out of the way, let's start by creating the `GlobalEdge`,
        // as that is the most straight-forward part of this operations, and
        // we're going to need it soon anyway.
        let (edge_global, vertices_global) = vertex
            .global_form()
            .clone()
            .sweep_with_cache(path, cache, objects);

        // Next, let's compute the surface coordinates of the two vertices of
        // the output `Edge`, as we're going to need these for the rest of this
        // operation.
        //
        // They both share a u-coordinate, which is the t-coordinate of our
        // input `Vertex`. Remember, we validated above, that the `Curve` of the
        // `Surface` and the curve of the input `Vertex` are the same, so we can
        // do that.
        //
        // Now remember what we also validated above: That `path`, which we're
        // using to create the output `Edge`, also created the `Surface`, and
        // thereby defined its coordinate system. That makes the v-coordinates
        // straight-forward: The start of the edge is at zero, the end is at
        // one.
        let points_surface = [
            Point::from([vertex.position().t, Scalar::ZERO]),
            Point::from([vertex.position().t, Scalar::ONE]),
        ];

        // Armed with those coordinates, creating the `Curve` of the output
        // `Edge` is straight-forward.
        let curve = {
            let (path, _) = SurfacePath::line_from_points(points_surface);

            Curve::new(surface.clone(), path, edge_global.curve().clone())
                .insert(objects)
        };

        let vertices_surface = {
            let [_, position] = points_surface;
            let [_, global_form] = vertices_global;

            [
                vertex.surface_form().clone(),
                SurfaceVertex::new(position, surface, global_form)
                    .insert(objects),
            ]
        };

        // And now the vertices. Again, nothing wild here.
        let vertices = vertices_surface.map(|surface_form| {
            Vertex::new(
                [surface_form.position().v],
                curve.clone(),
                surface_form,
            )
            .insert(objects)
        });

        // And finally, creating the output `Edge` is just a matter of
        // assembling the pieces we've already created.
        HalfEdge::new(vertices, edge_global).insert(objects)
    }

src/algorithms/sweep/edge.rs (line 75)

    fn sweep_with_cache(
        self,
        path: impl Into<Vector<3>>,
        cache: &mut SweepCache,
        objects: &mut Service<Objects>,
    ) -> Self::Swept {
        let (edge, color) = self;
        let path = path.into();

        let surface =
            edge.curve().clone().sweep_with_cache(path, cache, objects);

        // We can't use the edge we're sweeping from as the bottom edge, as that
        // is not defined in the right surface. Let's create a new bottom edge,
        // by swapping the surface of the original.
        let bottom_edge = {
            let vertices = edge.vertices();

            let points_curve_and_surface = vertices.clone().map(|vertex| {
                (vertex.position(), [vertex.position().t, Scalar::ZERO])
            });

            let curve = {
                // Please note that creating a line here is correct, even if the
                // global curve is a circle. Projected into the side surface, it
                // is going to be a line either way.
                let path =
                    SurfacePath::Line(Line::from_points_with_line_coords(
                        points_curve_and_surface,
                    ));

                Curve::new(
                    surface.clone(),
                    path,
                    edge.curve().global_form().clone(),
                )
                .insert(objects)
            };

            let vertices = {
                let points_surface = points_curve_and_surface
                    .map(|(_, point_surface)| point_surface);

                vertices
                    .each_ref_ext()
                    .into_iter_fixed()
                    .zip(points_surface)
                    .collect::<[_; 2]>()
                    .map(|(vertex, point_surface)| {
                        let surface_vertex = SurfaceVertex::new(
                            point_surface,
                            surface.clone(),
                            vertex.global_form().clone(),
                        )
                        .insert(objects);

                        Vertex::new(
                            vertex.position(),
                            curve.clone(),
                            surface_vertex,
                        )
                        .insert(objects)
                    })
            };

            HalfEdge::new(vertices, edge.global_form().clone()).insert(objects)
        };

        let side_edges = bottom_edge.vertices().clone().map(|vertex| {
            (vertex, surface.clone()).sweep_with_cache(path, cache, objects)
        });

        let top_edge = {
            let bottom_vertices = bottom_edge.vertices();

            let surface_vertices = side_edges.clone().map(|edge| {
                let [_, vertex] = edge.vertices();
                vertex.surface_form().clone()
            });

            let points_curve_and_surface =
                bottom_vertices.clone().map(|vertex| {
                    (vertex.position(), [vertex.position().t, Scalar::ONE])
                });

            let curve = {
                let global = bottom_edge
                    .curve()
                    .global_form()
                    .clone()
                    .translate(path, objects);

                // Please note that creating a line here is correct, even if the
                // global curve is a circle. Projected into the side surface, it
                // is going to be a line either way.
                let path =
                    SurfacePath::Line(Line::from_points_with_line_coords(
                        points_curve_and_surface,
                    ));

                Curve::new(surface, path, global).insert(objects)
            };

            let global = GlobalEdge::new(
                curve.global_form().clone(),
                surface_vertices
                    .clone()
                    .map(|surface_vertex| surface_vertex.global_form().clone()),
            )
            .insert(objects);

            let vertices = bottom_vertices
                .each_ref_ext()
                .into_iter_fixed()
                .zip(surface_vertices)
                .collect::<[_; 2]>()
                .map(|(vertex, surface_form)| {
                    Vertex::new(vertex.position(), curve.clone(), surface_form)
                        .insert(objects)
                });

            HalfEdge::new(vertices, global).insert(objects)
        };

        let cycle = {
            let a = bottom_edge;
            let [d, b] = side_edges;
            let c = top_edge;

            let mut edges = [a, b, c, d];

            // Make sure that edges are oriented correctly.
            let mut i = 0;
            while i < edges.len() {
                let j = (i + 1) % edges.len();

                let [_, prev_last] = edges[i].vertices();
                let [next_first, _] = edges[j].vertices();

                // Need to compare surface forms here, as the global forms might
                // be coincident when sweeping circles, despite the vertices
                // being different!
                if prev_last.surface_form().id()
                    != next_first.surface_form().id()
                {
                    edges[j] = edges[j].clone().reverse(objects);
                }

                i += 1;
            }

            Cycle::new(edges).insert(objects)
        };

        let face = PartialFace {
            exterior: Partial::from(cycle),
            color: Some(color),
            ..Default::default()
        };
        face.build(objects).insert(objects)
    }

Trait Implementations

impl Clone for Vertex

fn clone(&self) -> Vertex

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Vertex

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

Formats the value using the given formatter.

impl From<Vertex> for Object<Bare>

fn from(object: Vertex) -> Self

Converts to this type from the input type.

impl HasPartial for Vertex

type Partial = PartialVertex

The type representing the partial variant of this object

impl Hash for Vertex

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Insert for Vertex

fn insert(self, objects: &mut Service<Objects>) -> Handle<Self>

Insert the object into its respective store

impl Ord for Vertex

fn cmp(&self, other: &Vertex) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Vertex> for Vertex

fn eq(&self, other: &Vertex) -> 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 PartialOrd<Vertex> for Vertex

fn partial_cmp(&self, other: &Vertex) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl TransformObject for Vertex

fn transform_with_cache(
    self,
    transform: &Transform,
    objects: &mut Service<Objects>,
    cache: &mut TransformCache
) -> Self

Transform the object using the provided cache

fn transform(self, transform: &Transform, objects: &mut Service<Objects>) -> Self

Transform the object

fn translate(
    self,
    offset: impl Into<Vector<3>>,
    objects: &mut Service<Objects>
) -> Self

Translate the object

fn rotate(
    self,
    axis_angle: impl Into<Vector<3>>,
    objects: &mut Service<Objects>
) -> Self

Rotate the object

impl Validate for Vertex

type Error = VertexValidationError

The error that validation of the implementing type can result in

fn validate_with_config(
    &self,
    config: &ValidationConfig
) -> Result<(), Self::Error>

Validate the object

fn validate(&self) -> Result<(), Self::Error>

Validate the object using default configuration

impl Eq for Vertex

impl StructuralEq for Vertex

impl StructuralPartialEq for Vertex