delaunay 0.8.0

D-dimensional Delaunay triangulations and convex hulls in Rust, with exact predicates, deterministic degeneracy handling, explicit topology validation, and bistellar flips for finite point sets.
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

#![forbid(unsafe_code)]

//! Integration tests for workflows demonstrated by runnable examples.

use delaunay::prelude::construction::{
    DelaunayTriangulation, DelaunayTriangulationConstructionError,
};
use delaunay::prelude::geometry::{CoordinateConversionError, CoordinateValidationError};
use delaunay::prelude::query::{
    ConvexHull, ConvexHullConstructionError, ConvexHullValidationError, Point, QueryError,
    TopologyIndexBuildError,
};
use delaunay::prelude::validation::DelaunayTriangulationValidationError;
use delaunay::vertex;

#[test]
fn triangulation_and_hull_workflow_remains_valid() -> Result<(), WorkflowTestError> {
    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.35, 0.25, 0.20])?,
        vertex!([0.20, 0.60, 0.25])?,
    ];

    let dt: DelaunayTriangulation<_, (), (), 3> =
        DelaunayTriangulation::builder(&vertices).build()?;
    dt.validate()?;

    let edge_index = dt.build_edge_index()?;
    assert!(edge_index.number_of_edges() > 0);

    let boundary_facets: Vec<_> = dt
        .boundary_facets()?
        .map(|facet| {
            facet.map_err(|source| QueryError::TriangulationCorrupted {
                source: Box::new(source.into()),
            })
        })
        .collect::<Result<Vec<_>, _>>()?;
    assert!(!boundary_facets.is_empty());

    let hull = ConvexHull::try_from_triangulation(dt.as_triangulation())?;
    hull.validate(dt.as_triangulation())?;
    assert_eq!(hull.number_of_facets(), boundary_facets.len());

    let inside = Point::try_new([0.25, 0.25, 0.25])?;
    let outside = Point::try_new([2.0, 2.0, 2.0])?;

    assert!(!hull.is_point_outside(&inside, dt.as_triangulation())?);
    assert!(hull.is_point_outside(&outside, dt.as_triangulation())?);
    assert!(
        !hull
            .find_visible_facets(&outside, dt.as_triangulation())?
            .is_empty()
    );
    assert!(
        hull.find_nearest_visible_facet(&outside, dt.as_triangulation())?
            .is_some()
    );

    Ok(())
}

#[derive(Debug, thiserror::Error)]
enum WorkflowTestError {
    #[error(transparent)]
    Construction(#[from] DelaunayTriangulationConstructionError),
    #[error(transparent)]
    CoordinateConversion(#[from] CoordinateConversionError),
    #[error(transparent)]
    CoordinateValidation(#[from] CoordinateValidationError),
    #[error(transparent)]
    Validation(#[from] DelaunayTriangulationValidationError),
    #[error(transparent)]
    TopologyIndex(#[from] TopologyIndexBuildError),
    #[error(transparent)]
    Query(#[from] QueryError),
    #[error("convex hull construction failed: {source}")]
    ConvexHullConstruction {
        #[source]
        source: Box<ConvexHullConstructionError>,
    },
    #[error("convex hull validation failed: {source}")]
    ConvexHullValidation {
        #[source]
        source: Box<ConvexHullValidationError>,
    },
}

impl From<ConvexHullConstructionError> for WorkflowTestError {
    fn from(source: ConvexHullConstructionError) -> Self {
        Self::ConvexHullConstruction {
            source: Box::new(source),
        }
    }
}

impl From<ConvexHullValidationError> for WorkflowTestError {
    fn from(source: ConvexHullValidationError) -> Self {
        Self::ConvexHullValidation {
            source: Box::new(source),
        }
    }
}