delaunay 0.7.8

D-dimensional Delaunay triangulations and convex hulls in Rust, with exact predicates, multi-level validation, and bistellar flips
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

#![forbid(unsafe_code)]

//! # Numerical Robustness Example
//!
//! This example accompanies `docs/numerical_robustness_guide.md`.
//!
//! It compares kernel behavior on degenerate predicate inputs and shows the
//! default adaptive construction path on a small point set.

use delaunay::prelude::construction::{
    DelaunayTriangulation, DelaunayTriangulationConstructionError,
};
use delaunay::prelude::geometry::{
    AdaptiveKernel, CircumcenterError, Coordinate, CoordinateConversionError, FastKernel, Kernel,
    Point, RobustKernel, robust_insphere, robust_orientation,
};
use delaunay::prelude::validation::DelaunayTriangulationValidationError;
use delaunay::vertex;

#[derive(Debug, thiserror::Error)]
enum NumericalRobustnessExampleError {
    #[error(transparent)]
    Predicate(#[from] CircumcenterError),
    #[error(transparent)]
    CoordinateConversion(#[from] CoordinateConversionError),
    #[error(transparent)]
    Construction(#[from] DelaunayTriangulationConstructionError),
    #[error(transparent)]
    Validation(#[from] DelaunayTriangulationValidationError),
}

fn main() -> Result<(), NumericalRobustnessExampleError> {
    println!("Numerical robustness example");
    println!("============================\n");

    compare_orientation_kernels()?;
    println!();
    compare_insphere_boundary_handling()?;
    println!();
    build_with_adaptive_kernel()?;
    Ok(())
}

/// Compares orientation predicate behavior on a degenerate collinear simplex.
fn compare_orientation_kernels() -> Result<(), NumericalRobustnessExampleError> {
    let collinear = [
        Point::new([0.0, 0.0]),
        Point::new([1.0, 1.0]),
        Point::new([2.0, 2.0]),
    ];

    let fast = FastKernel::<f64>::new();
    let robust = RobustKernel::<f64>::new();
    let adaptive = AdaptiveKernel::<f64>::new();

    let direct_robust = robust_orientation(&collinear)?;
    let fast_sign = fast.orientation(&collinear)?;
    let robust_sign = robust.orientation(&collinear)?;
    let adaptive_sign = adaptive.orientation(&collinear)?;

    println!("Collinear orientation:");
    println!("  robust_orientation: {direct_robust:?}");
    println!("  FastKernel sign: {fast_sign}");
    println!("  RobustKernel sign: {robust_sign}");
    println!("  AdaptiveKernel sign with SoS tie-break: {adaptive_sign}");

    assert_eq!(robust_sign, 0);
    assert_ne!(adaptive_sign, 0);
    Ok(())
}

/// Compares explicit boundary reporting with adaptive `SoS` tie-breaking.
fn compare_insphere_boundary_handling() -> Result<(), NumericalRobustnessExampleError> {
    let simplex = [
        Point::new([0.0, 0.0]),
        Point::new([1.0, 0.0]),
        Point::new([0.0, 1.0]),
    ];
    let boundary_point = Point::new([1.0, 1.0]);

    let robust = RobustKernel::<f64>::new();
    let adaptive = AdaptiveKernel::<f64>::new();

    let direct_robust = robust_insphere(&simplex, &boundary_point)?;
    let robust_sign = robust.in_sphere(&simplex, &boundary_point)?;
    let adaptive_sign = adaptive.in_sphere(&simplex, &boundary_point)?;

    println!("Cospherical insphere query:");
    println!("  robust_insphere: {direct_robust:?}");
    println!("  RobustKernel sign: {robust_sign}");
    println!("  AdaptiveKernel sign with SoS tie-break: {adaptive_sign}");

    assert_eq!(robust_sign, 0);
    assert_ne!(adaptive_sign, 0);
    Ok(())
}

/// Builds a small triangulation with the default exact adaptive kernel and validates it.
fn build_with_adaptive_kernel() -> Result<(), NumericalRobustnessExampleError> {
    let vertices = vec![
        vertex!([0.0, 0.0, 0.0]),
        vertex!([1.0, 0.0, 0.0]),
        vertex!([0.0, 1.0, 0.0]),
        vertex!([0.0, 0.0, 1.0]),
        vertex!([0.25, 0.25, 0.25]),
    ];

    let dt: DelaunayTriangulation<AdaptiveKernel<f64>, (), (), 3> =
        DelaunayTriangulation::new(&vertices)?;

    dt.validate()?;
    println!(
        "Adaptive construction: {} vertices, {} simplices, full validation passed",
        dt.number_of_vertices(),
        dt.number_of_simplices()
    );
    Ok(())
}