polydf 0.1.1

Distance queries for parametric curves in 2D and 3D (nearest point, unsigned distance, early-out with speed bounds).
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

# polydf — Distance queries for parametric curves (2D & 3D)

polydf provides fast nearest-point queries from points to differentiable parametric curves:

- 2D curves: nearest parameter, closest point, unsigned distance, and a normal-based signed distance.
- 3D curves: nearest parameter, closest point, and unsigned distance.
- Optional conservative early-out when you have an upper bound on curve speed.

Highlights
- Works with closures and analytic functions; derivative is optional for 2D signing.
- Robust multi-start 1D minimization (Brent-like) over a user-provided `t` range.
- Tuple-friendly helpers and simple options for accuracy/performance tradeoffs.

Quick start (2D)
```rust
use nalgebra::{Vector2, vector};
use polydf::{NearestOptions, nearest_t};

fn circle(t: f32) -> Vector2<f32> { vector![t.cos(), t.sin()] }

let p = vector![1.5, 0.0];
let res = nearest_t(p, circle, 0.0..=std::f32::consts::TAU, NearestOptions::default());
assert!((res.distance - 0.5).abs() < 1e-3);
```

Quick start (3D)
```rust
use nalgebra::{Vector3, vector};
use polydf::{NearestOptions, nearest_t_3d};

fn helix(t: f32) -> Vector3<f32> { vector![t.cos(), t.sin(), 0.5 * t] }

let p = vector![2.0, 0.0, 0.0];
let res = nearest_t_3d(p, helix, -10.0..=10.0, NearestOptions::default());
println!("t* = {} d = {}", res.t, res.distance);
```

Early-out (needs speed upper bound)
```rust
use polydf::is_definitely_far_3d;
let threshold = 5.0f32;
let speed_ub = Some(1.2f32); // for helix
let far = is_definitely_far_3d(p, helix, -10.0..=10.0, threshold, speed_ub, 64);
```

Examples
- `cargo run --example render_curve` (2D image)
- `cargo run --example render_curve_with_derivative` (2D image with derivative)
- `cargo run --example nearest_helix_3d` (3D console demo)