Preliminary implementation

Author: radevgit

docs/NFP_CONVEX.md

@@ -0,0 +1,37 @@
+# NFP for Convex Polygons
+
+## The core concept for convex polygons:
+
+The No-Fit Polygon for two convex polygons can be computed using the **Minkowski Sum** approach. Specifically:
+
+$$\text{NFP}(A, B) = A \oplus (-B)$$
+
+where $\oplus$ is Minkowski sum and $-B$ means B reflected around the origin.
+
+## The algorithm steps:
+
+1. **Reflect B around origin**: Negate all coordinates of B's vertices, then reverse order (to maintain CCW)
+   
+2. **Compute convex hull of Minkowski sum**: 
+   - For each vertex of A and each vertex of reflected B, compute their Pairwise sum (vector addition)
+   - This gives a point cloud of all possible positions
+   - Compute convex hull of this point cloud
+   - The convex hull IS the NFP
+
+3. **Alternatively, simpler edge-merging approach**:
+   - Sort all edges from A and B by angle
+   - Merge them into one edge sequence (traversing both polygons' boundaries)
+   - Traverse this merged sequence while accumulating position to trace the NFP boundary
+   - This avoids computing convex hull explicitly
+
+## Recommended: Edge Merging Approach
+
+```
+1. Get all edges from A (as vectors)
+2. Get all edges from reflected B (as vectors)
+3. Combine into one list, sort by angle (atan2)
+4. Start at a reference point
+5. Traverse: follow each edge in sequence, tracking current position
+6. Each position becomes an NFP vertex
+```
+

docs/PointNFP.md

@@ -1,23 +1,23 @@
 use nfp::prelude::*;
-use std::time::Instant;
 
 /// Number of iterations to run the NFP calculation
 const ITERATIONS: usize = 1000;
 
 fn main() {
 
     // Generate two different 100-edge polygons with fixed seeds
-    let poly_a = generate_100_edge_polygon(42);
-    let poly_b = generate_100_edge_polygon(43);
+    let poly_a = generate_convex_100_edge_polygon(42);
+    let poly_b = generate_convex_100_edge_polygon(43);
 
     for _ in 0..ITERATIONS {
-        let _ = NFP::nfp(&poly_a, &poly_b);
+        let _ = NFPConvex::nfp(&poly_a, &poly_b);
     }
 }
 
 /// Generate a 100-edge polygon using a fixed seed via bit manipulation
-fn generate_100_edge_polygon(seed: u64) -> Vec<Point> {
+fn generate_convex_100_edge_polygon(seed: u64) -> Vec<Point> {
     use std::f64::consts::PI;
+    use togo::algo::pointline_convex_hull;
 
     let mut points = Vec::new();
     let mut rng_state = seed;
@@ -35,15 +35,16 @@ fn generate_100_edge_polygon(seed: u64) -> Vec<Point> {
         points.push(point(radius * angle.cos(), radius * angle.sin()));
     }
 
-    // Sort by angle from centroid to ensure CCW ordering
+    // Sort by angle from centroid to ensure CCW ordering (required by convex_hull)
     let centroid = compute_centroid(&points);
     points.sort_by(|a, b| {
         let angle_a = (a.y - centroid.y).atan2(a.x - centroid.x);
         let angle_b = (b.y - centroid.y).atan2(b.x - centroid.x);
         angle_a.partial_cmp(&angle_b).unwrap_or(std::cmp::Ordering::Equal)
     });
 
-    points
+    // Apply convex hull to ensure convex polygon (expects CCW input)
+    pointline_convex_hull(&points)
 }
 
 fn compute_centroid(points: &[Point]) -> Point {