openstellaris/triangle/src/lib.rs

#[macro_use]
extern crate derive_builder;
extern crate triangle_sys as sys;

#[cfg(test)]
mod tests;

use std::{ffi::CString, mem::MaybeUninit, ptr};

use anyhow::Result;

#[derive(Builder)]
pub struct TrianglulateOpts<P = Vec<Point>> {
  point_list: P,

  /// Generates a Voronoi diagram
  #[builder(default)]
  voronoi: bool,
}

impl<P: Clone> TrianglulateOpts<P> {
  pub fn builder() -> TrianglulateOptsBuilder<P> {
    TrianglulateOptsBuilder::default()
  }
}

#[derive(Clone, Copy, Debug)]
pub struct Point {
  pub x: f64,
  pub y: f64,
}

#[derive(Debug)]
pub struct TriangulateResult {
  pub point_list: Vec<Point>,
  pub voronoi_point_list: Vec<Point>,
}

pub fn triangulate<P>(opts: TrianglulateOpts<P>) -> Result<TriangulateResult>
where
  P: IntoIterator<Item = Point>,
{
  let mut switches = Vec::new();
  switches.push("p");
  switches.push("c");
  switches.push("z");
  switches.push("A");
  switches.push("e");
  switches.push("n");
  if opts.voronoi {
    switches.push("v");
  }

  let switches = CString::new(switches.join(""))?;

  let point_list = opts.point_list.into_iter().collect::<Vec<_>>();

  let mut flat_point_list = point_list
    .iter()
    .flat_map(|point| [point.x, point.y])
    .collect::<Vec<_>>();

  let input = MaybeUninit::<sys::triangulateio>::zeroed();
  let output = MaybeUninit::<sys::triangulateio>::zeroed();
  let vorout = MaybeUninit::<sys::triangulateio>::zeroed();

  let mut input = unsafe { input.assume_init() };
  let mut output = unsafe { output.assume_init() };
  let mut vorout = unsafe { vorout.assume_init() };

  input.pointlist = flat_point_list.as_mut_ptr();
  input.numberofpoints = point_list.len() as i32;

  // TODO: Implement point attributes
  input.numberofpointattributes = 0;

  println!("Going to triangulate...");

  unsafe {
    sys::triangulate(
      switches.as_ptr() as *mut _,
      &mut input as *mut _,
      &mut output as *mut _,
      &mut vorout as *mut _,
    )
  };

  println!("Triangulated {}.", output.numberoftriangles);

  let point_list = point_list_from_flat_point_list(
    output.pointlist,
    output.numberofpoints as usize * 2,
  );

  let voronoi_point_list = point_list_from_flat_point_list(
    vorout.pointlist,
    vorout.numberofpoints as usize * 2,
  );

  Ok(TriangulateResult {
    point_list,
    voronoi_point_list,
  })
}

fn point_list_from_flat_point_list(ptr: *mut f64, len: usize) -> Vec<Point> {
  let flat_point_list = unsafe { Vec::from_raw_parts(ptr, len, len) };
  flat_point_list
    .chunks(2)
    .map(|points| Point {
      x: points[0],
      y: points[1],
    })
    .collect::<Vec<_>>()
}