Struct WeightedEdge 

pub struct WeightedEdge {
    pub a: WeightedVertex,
    pub b: WeightedVertex,
    /* private fields */
}

A weighted 1-simplex in 2-dimensional space.

Fields

a: WeightedVertex

b: WeightedVertex

Implementations

impl WeightedEdge

pub fn new(a: WeightedVertex, b: WeightedVertex) -> Self

pub fn with_triangles( a: WeightedVertex, b: WeightedVertex, triangles: [Option<WeightedTriangle>; 2], ) -> Self

Create a new edge with the given triangles as incident triangles

pub fn set_triangles(&mut self, triangles: [Option<WeightedTriangle>; 2])

Set the incident triangles of the edge

pub fn vertices(&self) -> Vec<WeightedVertex>

Trait Implementations

impl Clone for WeightedEdge

fn clone(&self) -> WeightedEdge

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WeightedEdge

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

Formats the value using the given formatter.

impl Display for WeightedEdge

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

Formats the value using the given formatter.

impl Hash for WeightedEdge

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 WeightedEdge

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for WeightedEdge

fn eq(&self, other: &WeightedEdge) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for WeightedEdge

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl TriangleLogic<WeightedVertex, WeightedEdge, WeightedTriangle> for WeightedTriangle

fn area(&self) -> f64

The area of the triangle.

Example

use cg_math::geometry::{WeightedVertex, WeightedTriangle, TriangleLogic};
 
let v0 = WeightedVertex::new(2.5, 2.0, 0.0);
let v1 = WeightedVertex::new(1.0, 2.5, 0.0);
let v2 = WeightedVertex::new(2.0, 3.0, 0.0);
 
let triangle = WeightedTriangle::new(v0, v1, v2);
 
assert_eq!(triangle.area(), 0.625);

fn area3d(&self) -> f64

The area of the triangle lifted to 3d with $z = x^2 + y^2 - w$.

Example

use cg_math::geometry::{WeightedVertex, WeightedTriangle, TriangleLogic};
 
let v0 = WeightedVertex::new(2.5, 2.0, 1.0);
let v1 = WeightedVertex::new(1.0, 2.5, 2.0);
let v2 = WeightedVertex::new(2.0, 3.0, 3.0);
 
let triangle = WeightedTriangle::new(v0, v1, v2);
 
//assert_eq!(triangle.area3d(), 1.3975424859373686);

fn has_edge(&self, edge: &WeightedEdge) -> bool

Check if the given edge is part of the triangle.

fn has_vertex(&self, vertex: &WeightedVertex) -> bool

Check if the given vertex is part of the triangle.

fn is_regular(&self, vertex: &WeightedVertex) -> bool

Check whether the triangle is regular w.r.t to the given vertex.

use cg_math::{geometry::{WeightedVertex, WeightedTriangle, TriangleLogic}, utils::c_hull};
 
// these 4 vertices span two of the three triangles in the triangulation
let v0 = WeightedVertex::new(6.24, 8.38, 2.24);
let v1 = WeightedVertex::new(9.34, 9.19, 7.46);  // assume this one was inserted last
let v2 = WeightedVertex::new(8.04, 5.53, 7.53);
let v3 = WeightedVertex::new(8.53, 8.43, 1.34);
 
assert_eq!(WeightedTriangle::new(v0, v2, v3).is_regular(&v1), false);

fn is_eps_regular(&self, vertex: &WeightedVertex, epsilon: f64) -> bool

Check whether the triangle is regular w.r.t to the given vertex; by tolerance of epsilon.

fn orientation(&self) -> f64

The orientation of the triangle; clockwise (cw) or counter-cw.

Panics

If the triangle consists of three collinear points.

fn regularity(&self, vertex: &WeightedVertex) -> f64

Compute the level of local regularity w.r.t to the given vertex

fn is_neighbor(&self, other: &WeightedTriangle) -> Option<WeightedEdge>

Check if this and the other triangle share an edge, i.e. are neighbors and return it if existing

fn edges(&self) -> Vec<WeightedEdge>

fn vertices(&self) -> Vec<WeightedVertex>

impl Copy for WeightedEdge

impl Eq for WeightedEdge

impl StructuralPartialEq for WeightedEdge