Struct Delaunator 

pub struct Delaunator {
    pub coords: Vec<f64>,
    pub triangles: Vec<usize>,
    pub halfedges: Vec<usize>,
    pub hull: Vec<usize>,
    pub triangles_len: usize,
    /* private fields */
}

Delaunator

Description

An incredibly fast and robust Typescript library for Delaunay triangulation of 2D points.

Usage

The methods you have access to:

• Delaunator::new: Create a new Delaunator
• Delaunator::from_points: Given a flattened array of x,y points. e.g. [[x1, y1], [x2, y2], ...]
• [Delaunator::from_vector_points]: Create a new Delaunator from a collection of VectorPoints
• Delaunator::update: Updates the triangulation if you modified delaunay.

The properties you have access to:

• Delaunator::coords: coordinates of each point
• Delaunator::triangles: indexes to each triangle. (triangle[i * 3], triangle[(i * 3) + 1], triangle[(i * 3) + 2])
• Delaunator::halfedges: indexes to each half edge. (halfedge[i], halfedge[(i + 1) % 3], halfedge[(i + 2) % 3])
• Delaunator::hull: indexes to each point on the convex hull
• Delaunator::triangles_len: length of the triangles array

use gistools::tools::Delaunator;
use s2json::Point;

let points = vec![
    Point(382., 302.),
    Point(382., 328.),
    Point(382., 205.),
    Point(623., 175.),
    Point(382., 188.),
    Point(382., 284.),
    Point(623., 87.),
    Point(623., 341.),
    Point(141., 227.),
];
let del = Delaunator::from_points(&points);

Links

• https://en.wikipedia.org/wiki/Delaunay_triangulation

Fields

coords: Vec<f64>

coordinates of each point

triangles: Vec<usize>

indexes to each triangle. (triangle[i * 3], triangle[(i * 3) + 1], triangle[(i * 3) + 2]) makes a triangle

halfedges: Vec<usize>

indexes to each half edge. (halfedge[i], halfedge[(i + 1) % 3], halfedge[(i + 2) % 3])

hull: Vec<usize>

indexes to each point on the convex hull

triangles_len: usize

length of the triangles array

Implementations

impl Delaunator

pub fn new(coords: Vec<f64>) -> Delaunator

Constructs a delaunay triangulation object given an array of point coordinates of the form: [x0, y0, x1, y1, ...] (use a typed array for best performance).

Parameters

• coords: flattened array of x,y points. e.g. [x1, y1, x2, y2, ...]

Returns

A new Delaunator object

pub fn from_points<P: GetXY>(points: &[P]) -> Delaunator

Given a collection of points that contain an x and y property, returns a new Delaunator object.

Returns

A Delaunator class to do Delaunay triangulation

pub fn update(&mut self)

Updates the triangulation if you modified delaunay. Coords values in place, avoiding expensive memory allocations. Useful for iterative relaxation algorithms such as Lloyd’s.

Trait Implementations

impl Debug for Delaunator

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

Formats the value using the given formatter.