use crate::interpolation;
use crate::Triangulation;
use std::ffi::CStr;
use std::os::raw::c_char;
use std::os::raw::c_double;
use std::os::raw::c_int;
use std::os::raw::c_ulong;
#[no_mangle]
pub extern "C" fn new_triangulation() -> *mut Triangulation {
let x = Box::new(Triangulation::new());
let ptr = Box::into_raw(x);
return ptr;
}
#[no_mangle]
pub extern "C" fn destroy(ptr: *mut Triangulation) {
unsafe { drop(Box::from_raw(ptr)) };
}
#[no_mangle]
pub extern "C" fn insert_one_pt(
ptr: *mut Triangulation,
px: c_double,
py: c_double,
pz: c_double,
) -> usize {
let t = unsafe { ptr.as_mut().unwrap() };
let re = Triangulation::insert_one_pt(t, px, py, pz);
match re {
Ok(pointid) => return pointid,
Err(_) => return 0,
};
}
#[no_mangle]
pub extern "C" fn remove(ptr: *mut Triangulation, vi: c_ulong) -> c_int {
let t = unsafe { ptr.as_mut().unwrap() };
let re = Triangulation::remove(t, vi as usize);
match re {
Ok(_) => return 0,
Err(_) => return 1,
};
}
#[no_mangle]
pub extern "C" fn adjacent_vertices_to_vertex(ptr: *mut Triangulation, vi: c_ulong) -> *mut u64 {
let t = unsafe { ptr.as_mut().unwrap() };
let re = Triangulation::adjacent_vertices_to_vertex(t, vi as usize);
let mut adjs: Vec<u64> = Vec::new();
if re.is_ok() {
let a = re.unwrap();
adjs.push(a.len() as u64);
for each in a {
adjs.push(each as u64);
}
} else {
adjs.push(0);
}
let ptr = adjs.as_mut_ptr();
std::mem::forget(adjs); ptr
}
#[no_mangle]
pub extern "C" fn insert(
ptr: *mut Triangulation,
length: c_int,
arr: *mut c_double,
strategy: *const c_char,
) {
let istrategy = unsafe {
assert!(!strategy.is_null());
CStr::from_ptr(strategy)
};
let dt = unsafe { ptr.as_mut().unwrap() };
let slice = unsafe { std::slice::from_raw_parts(arr, length as usize) };
let iter = slice.chunks(3);
match istrategy.to_str().unwrap() {
"AsIs" => {
for p in iter {
let _re = Triangulation::insert_one_pt(dt, p[0], p[1], p[2]);
}
}
"BBox" => {
let mut bbox = Triangulation::get_bbox(dt);
bbox[0] = bbox[0] - 10.0;
bbox[1] = bbox[1] - 10.0;
bbox[2] = bbox[2] + 10.0;
bbox[3] = bbox[3] + 10.0;
let mut c4: Vec<usize> = Vec::new();
c4.push(Triangulation::insert_one_pt(dt, bbox[0], bbox[1], 0.0).unwrap());
c4.push(Triangulation::insert_one_pt(dt, bbox[2], bbox[1], 0.0).unwrap());
c4.push(Triangulation::insert_one_pt(dt, bbox[2], bbox[3], 0.0).unwrap());
c4.push(Triangulation::insert_one_pt(dt, bbox[0], bbox[3], 0.0).unwrap());
for p in iter {
let _re = Triangulation::insert_one_pt(dt, p[0], p[1], p[2]);
}
for each in &c4 {
let _re = Triangulation::remove(dt, *each);
}
}
_ => {
for p in iter {
let _re = Triangulation::insert_one_pt(dt, p[0], p[1], p[2]);
}
}
}
}
#[no_mangle]
pub extern "C" fn interpolate_nn(ptr: *mut Triangulation, px: c_double, py: c_double) -> c_double {
let t = unsafe { ptr.as_mut().unwrap() };
let interpol = interpolation::NN {};
let mut re = interpolation::interpolate(&interpol, t, &vec![[px, py]]);
let re1 = re.pop().expect("no results");
return re1.unwrap_or(std::f64::NAN);
}
#[no_mangle]
pub extern "C" fn interpolate_linear(
ptr: *mut Triangulation,
px: c_double,
py: c_double,
) -> c_double {
let t = unsafe { ptr.as_mut().unwrap() };
let interpol = interpolation::TIN {};
let mut re = interpolation::interpolate(&interpol, t, &vec![[px, py]]);
let re1 = re.pop().expect("no results");
return re1.unwrap_or(std::f64::NAN);
}
#[no_mangle]
pub extern "C" fn interpolate_nni(ptr: *mut Triangulation, px: c_double, py: c_double) -> c_double {
let t = unsafe { ptr.as_mut().unwrap() };
let interpol = interpolation::NNI { precompute: false };
let mut re = interpolation::interpolate(&interpol, t, &vec![[px, py]]);
let re1 = re.pop().expect("no results");
return re1.unwrap_or(std::f64::NAN);
}
#[no_mangle]
pub extern "C" fn interpolate_laplace(
ptr: *mut Triangulation,
px: c_double,
py: c_double,
) -> c_double {
let t = unsafe { ptr.as_mut().unwrap() };
let interpol = interpolation::Laplace {};
let mut re = interpolation::interpolate(&interpol, t, &vec![[px, py]]);
let re1 = re.pop().expect("no results");
return re1.unwrap_or(std::f64::NAN);
}
#[no_mangle]
pub extern "C" fn write_obj(ptr: *mut Triangulation, s: *const c_char) -> c_int {
let t = unsafe { ptr.as_mut().unwrap() };
let path = unsafe {
assert!(!s.is_null());
CStr::from_ptr(s)
};
let re = Triangulation::write_obj(t, path.to_str().unwrap().to_string());
if re.is_err() {
return 1;
}
return 0;
}
#[no_mangle]
pub extern "C" fn write_ply(ptr: *mut Triangulation, s: *const c_char) -> c_int {
let t = unsafe { ptr.as_mut().unwrap() };
let path = unsafe {
assert!(!s.is_null());
CStr::from_ptr(s)
};
let re = Triangulation::write_ply(t, path.to_str().unwrap().to_string());
if re.is_err() {
return 1;
}
return 0;
}
#[no_mangle]
pub extern "C" fn get_snap_tolerance(ptr: *mut Triangulation) -> c_double {
let t = unsafe { ptr.as_mut().unwrap() };
let re = Triangulation::get_snap_tolerance(t);
return re;
}
#[no_mangle]
pub extern "C" fn set_snap_tolerance(ptr: *mut Triangulation, tolerance: c_double) -> c_double {
let t = unsafe { ptr.as_mut().unwrap() };
let re = Triangulation::set_snap_tolerance(t, tolerance);
return re;
}
#[no_mangle]
pub extern "C" fn printme(ptr: *mut Triangulation) -> c_int {
let t = unsafe { ptr.as_mut().unwrap() };
println!("Vertices: {}", t.number_of_vertices());
println!("Triangles: {}", t.number_of_triangles());
println!("Convex points: {}", t.number_of_vertices_on_convex_hull());
println!("Robust?: {}", t.robust_predicates);
return 0;
}