Struct fj_kernel::algorithms::approx::cycle::CycleApprox

pub struct CycleApprox {
    pub half_edges: Vec<HalfEdgeApprox>,
}

An approximation of a Cycle

Fields

half_edges: Vec<HalfEdgeApprox>

The approximated edges that make up the approximated cycle

Implementations

impl CycleApprox

pub fn points(&self) -> Vec<ApproxPoint<2>>

Compute the points that approximate the cycle

Examples found in repository

src/algorithms/approx/face.rs (line 133)

    pub fn points(&self) -> BTreeSet<ApproxPoint<2>> {
        let mut points = BTreeSet::new();

        points.extend(self.exterior.points());

        for cycle_approx in &self.interiors {
            points.extend(cycle_approx.points());
        }

        points
    }

src/algorithms/approx/cycle.rs (line 60)

    pub fn segments(&self) -> Vec<Segment<3>> {
        let mut segments = Vec::new();

        for segment in self.points().windows(2) {
            // This can't panic, as we passed `2` to `windows`. Can be cleaned
            // up, once `array_windows` is stable.
            let segment = [&segment[0], &segment[1]];

            segments
                .push(Segment::from(segment.map(|point| point.global_form)));
        }

        segments
    }

src/algorithms/triangulate/mod.rs (line 50)

    fn triangulate_into_mesh(self, mesh: &mut Mesh<Point<3>>) {
        let face_as_polygon = Polygon::new()
            .with_exterior(
                self.exterior
                    .points()
                    .into_iter()
                    .map(|point| point.local_form),
            )
            .with_interiors(self.interiors.iter().map(|interior| {
                interior.points().into_iter().map(|point| point.local_form)
            }));

        let cycles = [self.exterior].into_iter().chain(self.interiors);
        let mut triangles =
            delaunay::triangulate(cycles, self.coord_handedness);
        triangles.retain(|triangle| {
            face_as_polygon
                .contains_triangle(triangle.map(|point| point.point_surface))
        });

        for triangle in triangles {
            let points = triangle.map(|point| point.point_global);
            mesh.push_triangle(points, self.color);
        }
    }

src/algorithms/triangulate/delaunay.rs (line 22)

pub fn triangulate(
    cycles: impl IntoIterator<Item = CycleApprox>,
    coord_handedness: Handedness,
) -> Vec<[TriangulationPoint; 3]> {
    use spade::Triangulation as _;

    let mut triangulation = spade::ConstrainedDelaunayTriangulation::<_>::new();

    let mut points = BTreeMap::new();

    for cycle_approx in cycles {
        let mut handle_prev = None;

        for point in cycle_approx.points() {
            let handle = match points.get(&point) {
                Some(handle) => *handle,
                None => {
                    let handle = triangulation
                        .insert(TriangulationPoint {
                            point_surface: point.local_form,
                            point_global: point.global_form,
                        })
                        .expect("Inserted invalid point into triangulation");

                    points.insert(point, handle);

                    handle
                }
            };

            if let Some(handle_prev) = handle_prev {
                triangulation.add_constraint(handle_prev, handle);
            }

            handle_prev = Some(handle);
        }
    }

    let mut triangles = Vec::new();
    for triangle in triangulation.inner_faces() {
        let [v0, v1, v2] = triangle.vertices().map(|vertex| *vertex.data());
        let triangle_winding = Triangle::<2>::from_points([
            v0.point_surface,
            v1.point_surface,
            v2.point_surface,
        ])
        .expect("invalid triangle")
        .winding();

        let required_winding = match coord_handedness {
            Handedness::LeftHanded => Winding::Cw,
            Handedness::RightHanded => Winding::Ccw,
        };

        let triangle = if triangle_winding == required_winding {
            [v0, v1, v2]
        } else {
            [v0, v2, v1]
        };

        triangles.push(triangle);
    }

    triangles
}

pub fn segments(&self) -> Vec<Segment<3>>

Construct the segments that approximate the cycle

Trait Implementations

impl Debug for CycleApprox

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

Formats the value using the given formatter.

impl Hash for CycleApprox

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 Ord for CycleApprox

fn cmp(&self, other: &CycleApprox) -> 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<CycleApprox> for CycleApprox

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

fn partial_cmp(&self, other: &CycleApprox) -> 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 Eq for CycleApprox

impl StructuralEq for CycleApprox

impl StructuralPartialEq for CycleApprox