UniFFI

Author: urschrei

Cargo.toml

@@ -16,19 +16,27 @@ libc = "0.2.174"
 geo = "0.31.0"
 geo-types = "0.7.13"
 num-traits = "0.2.19"
+uniffi = "0.28"
+thiserror = "2.0"
+uniffi_bindgen = { version = "0.28", optional = true }
+camino = { version = "1.1", optional = true }
 
 [dev-dependencies]
 criterion = "0.7"
+uniffi_bindgen = "0.28"
 
 [build-dependencies]
 cbindgen = "0.29.0"
+uniffi = { version = "0.28", features = ["build", "bindgen"] }
 
 [features]
 headers = []
+python-bindings = []
+bindgen = ["uniffi_bindgen", "camino"]
 
 [lib]
 name = "rdp"
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "lib"]
 test = true
 doctest = false
 doc = true

build.rs

@@ -12,6 +12,14 @@ fn write_headers() {
 }
 
 fn main() {
+    // Generate UniFFI scaffolding
+    uniffi::generate_scaffolding("src/rdp.udl").unwrap();
+    
+    // Note: Python bindings generation happens at runtime
+    // Users can generate them manually using:
+    // cargo run --bin uniffi-bindgen generate src/rdp.udl --language python --out-dir python
+    
+    // Keep existing cbindgen for backward compatibility
     let headers_enabled = env::var_os("CARGO_FEATURE_HEADERS").is_some();
     if headers_enabled {
         write_headers();

examples/uniffi_example.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python
+"""
+uniffi_example.py
+
+Example of using the UniFFI-generated Python bindings for the RDP library.
+This demonstrates the simplified interface compared to the manual ctypes FFI.
+
+To run:
+1. Build the library with Python bindings: cargo build --release --features python-bindings
+2. Ensure the generated Python module is in your path
+3. Run this script: python examples/uniffi_example.py
+"""
+
+import os
+import sys
+from enum import Enum
+
+import numpy as np
+
+# Add the python directory to the path to import the generated bindings
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "python"))
+
+try:
+    # Import the UniFFI generated module
+    import rdp
+except ImportError:
+    print(
+        "Could not import rdp module. Make sure to build with: cargo build --release --features python-bindings"
+    )
+    sys.exit(1)
+
+
+class Algorithm(Enum):
+    """Simplification algorithms available."""
+
+    RDP = "rdp"  # Ramer-Douglas-Peucker
+    VW = "vw"  # Visvalingam-Whyatt
+    VWP = "vwp"  # Visvalingam-Whyatt with topology preservation
+
+
+def simplify_linestring(coords, precision, algorithm=Algorithm.RDP):
+    """
+    Simplify a linestring using the specified algorithm.
+
+    Args:
+        coords: numpy array of shape (n, 2) or list of [x, y] pairs
+        precision: simplification tolerance
+        algorithm: Algorithm enum value
+
+    Returns:
+        Simplified coordinates as numpy array
+    """
+    # Convert to flat list efficiently
+    flat = np.asarray(coords, dtype=np.float64).flatten().tolist()
+
+    # Map algorithm to corresponding function
+    algorithm_map = {
+        Algorithm.RDP: rdp.simplify_rdp,
+        Algorithm.VW: rdp.simplify_visvalingam,
+        Algorithm.VWP: rdp.simplify_visvalingam_preserve,
+    }
+
+    try:
+        simplify_func = algorithm_map[algorithm]
+        result = simplify_func(flat, precision)
+    except KeyError:
+        raise ValueError(f"Unknown algorithm: {algorithm}")
+    except rdp.RdpError as e:
+        print(f"Error during simplification: {e}")
+        raise
+
+    # Reshape back to (n, 2)
+    return np.array(result).reshape(-1, 2)
+
+
+def simplify_indices(coords, precision, algorithm=Algorithm.RDP):
+    """
+    Get indices of points to keep after simplification.
+
+    Args:
+        coords: numpy array of shape (n, 2) or list of [x, y] pairs
+        precision: simplification tolerance
+        algorithm: Algorithm enum value (RDP or VW only)
+
+    Returns:
+        Indices of points to keep
+    """
+    # Convert to flat list
+    flat = np.asarray(coords, dtype=np.float64).flatten().tolist()
+
+    # Map algorithm to corresponding function
+    algorithm_map = {
+        Algorithm.RDP: rdp.simplify_rdp_idx,
+        Algorithm.VW: rdp.simplify_visvalingam_idx,
+    }
+
+    try:
+        simplify_func = algorithm_map[algorithm]
+        result = simplify_func(flat, precision)
+    except KeyError:
+        raise ValueError(f"Algorithm {algorithm} does not support index output")
+    except rdp.RdpError as e:
+        print(f"Error during simplification: {e}")
+        raise
+
+    return np.array(result, dtype=np.uint64)
+
+
+def main():
+    # Example 1: RDP simplification
+    print("Example 1: Ramer-Douglas-Peucker Simplification")
+    print("-" * 50)
+
+    coords_rdp = np.array(
+        [[0.0, 0.0], [5.0, 4.0], [11.0, 5.5], [17.3, 3.2], [27.8, 0.1]]
+    )
+
+    print(f"Original points ({len(coords_rdp)} points):")
+    print(coords_rdp)
+
+    simplified_rdp = simplify_linestring(coords_rdp, 1.0, Algorithm.RDP)
+    print(f"\nSimplified with RDP (tolerance=1.0, {len(simplified_rdp)} points):")
+    print(simplified_rdp)
+
+    indices_rdp = simplify_indices(coords_rdp, 1.0, Algorithm.RDP)
+    print(f"\nIndices of kept points: {indices_rdp}")
+
+    # Example 2: Visvalingam-Whyatt simplification
+    print("\n\nExample 2: Visvalingam-Whyatt Simplification")
+    print("-" * 50)
+
+    coords_vw = np.array(
+        [[5.0, 2.0], [3.0, 8.0], [6.0, 20.0], [7.0, 25.0], [10.0, 10.0]]
+    )
+
+    print(f"Original points ({len(coords_vw)} points):")
+    print(coords_vw)
+
+    simplified_vw = simplify_linestring(coords_vw, 30.0, Algorithm.VW)
+    print(f"\nSimplified with VW (epsilon=30.0, {len(simplified_vw)} points):")
+    print(simplified_vw)
+
+    indices_vw = simplify_indices(coords_vw, 30.0, Algorithm.VW)
+    print(f"\nIndices of kept points: {indices_vw}")
+
+    # Example 3: Topology-preserving Visvalingam-Whyatt
+    print("\n\nExample 3: Topology-Preserving Visvalingam-Whyatt")
+    print("-" * 50)
+
+    simplified_vwp = simplify_linestring(coords_vw, 30.0, Algorithm.VWP)
+    print(f"Simplified with VWP (epsilon=30.0, {len(simplified_vwp)} points):")
+    print(simplified_vwp)
+
+    # Example 4: Error handling
+    print("\n\nExample 4: Error Handling")
+    print("-" * 50)
+
+    try:
+        # Try with invalid input (odd number of coordinates)
+        invalid_coords = [1.0, 2.0, 3.0]
+        rdp.simplify_rdp(invalid_coords, 1.0)
+    except (rdp.RdpError, rdp.InternalError) as e:
+        print(f"Caught expected error for invalid input: {e}")
+
+    try:
+        # Try with empty input
+        empty_coords = []
+        rdp.simplify_rdp(empty_coords, 1.0)
+    except (rdp.RdpError, rdp.InternalError) as e:
+        print(f"Caught expected error for empty input: {e}")
+
+    print('"All examples completed successfully!')
+
+
+if __name__ == "__main__":
+    main()

generate_bindings.rs

@@ -0,0 +1,29 @@
+#!/usr/bin/env rust-script
+//! Generate Python bindings for the RDP library
+//!
+//! To run: rustc generate_bindings.rs && ./generate_bindings
+
+use std::path::PathBuf;
+
+fn main() {
+    println!("Generating Python bindings...");
+    
+    let udl_file = PathBuf::from("src/rdp.udl");
+    let out_dir = PathBuf::from("python");
+    
+    // Create output directory
+    std::fs::create_dir_all(&out_dir).expect("Failed to create python directory");
+    
+    // Generate Python bindings
+    uniffi_bindgen::generate_bindings(
+        &udl_file,
+        None,
+        vec![uniffi_bindgen::bindings::TargetLanguage::Python],
+        Some(&out_dir),
+        None,
+        &uniffi_bindgen::Config::default(),
+        false,
+    ).expect("Failed to generate Python bindings");
+    
+    println!("Python bindings generated in python/ directory");
+}