Struct Point 

pub struct Point { /* private fields */ }

A geographic point with longitude/latitude coordinates.

This wraps geo::Point and provides additional functionality for GeoJSON conversion, distance calculations, and other operations.

Examples

use spatio_types::geo::Point;

let nyc = Point::new(-74.0060, 40.7128);
assert_eq!(nyc.x(), -74.0060);
assert_eq!(nyc.y(), 40.7128);

Implementations

impl Point

pub fn new(x: f64, y: f64) -> Point

Create a new point from x (longitude) and y (latitude) coordinates.

Arguments

• x - Longitude in degrees (typically -180 to 180)
• y - Latitude in degrees (typically -90 to 90)

Examples

use spatio_types::geo::Point;

let point = Point::new(-74.0060, 40.7128);

Examples found in repository

examples/getting_started.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging (set RUST_LOG=debug to see detailed logs)
    env_logger::init();

    println!("=== Spatio - Getting Started ===\n");

    // Create an in-memory database
    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // === BASIC KEY-VALUE STORAGE ===
    println!("1. Basic Key-Value Storage");
    println!("---------------------------");

    db.insert("user:123", b"John Doe", None)?;
    let value = db.get("user:123")?.unwrap();
    println!("   Stored: user:123 = {}", String::from_utf8_lossy(&value));

    // Store data with TTL (time-to-live)
    let ttl_options = SetOptions::with_ttl(Duration::from_secs(5));
    db.insert("session:abc", b"expires_soon", Some(ttl_options))?;
    println!("   Stored session data with 5-second TTL\n");

    // === SPATIAL OPERATIONS ===
    println!("2. Spatial Point Storage");
    println!("------------------------");

    // Store geographic points (lon, lat format)
    let nyc = Point::new(-74.0060, 40.7128);
    let london = Point::new(-0.1278, 51.5074);
    let paris = Point::new(2.3522, 48.8566);

    db.insert_point("cities", &nyc, b"New York", None)?;
    db.insert_point("cities", &london, b"London", None)?;
    db.insert_point("cities", &paris, b"Paris", None)?;
    println!("   Stored 3 cities with automatic spatial indexing");

    // Find nearby cities within radius (in meters)
    let nearby = db.query_within_radius("cities", &london, 500_000.0, 10)?;
    println!("   Found {} cities within 500km of London:", nearby.len());
    for (_, data, _) in &nearby {
        println!("     - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === SPATIAL QUERY METHODS ===
    println!("3. Spatial Query Methods");
    println!("------------------------");

    // Check if any points exist within radius
    let has_nearby = db.intersects_radius("cities", &paris, 1_000_000.0)?;
    println!("   Cities within 1000km of Paris: {}", has_nearby);

    // Count points within radius
    let count = db.count_within_radius("cities", &nyc, 6_000_000.0)?;
    println!("   Cities within 6000km of NYC: {}", count);

    // Find points within bounding box (min_lon, min_lat, max_lon, max_lat)
    let results = db.find_within_bounds("cities", -10.0, 40.0, 10.0, 55.0, 10)?;
    println!("   Cities in European bounding box: {}", results.len());
    for (_point, data) in results {
        println!("     - {}", String::from_utf8_lossy(&data));
    }
    println!();

    // === ATOMIC OPERATIONS ===
    println!("4. Atomic Batch Operations");
    println!("---------------------------");

    db.atomic(|batch| {
        batch.insert("sensor:temp", b"22.5C", None)?;
        batch.insert("sensor:humidity", b"65%", None)?;
        batch.insert("sensor:pressure", b"1013 hPa", None)?;
        Ok(())
    })?;
    println!("   Atomically inserted 3 sensor readings\n");

    // === TRAJECTORY TRACKING ===
    println!("5. Trajectory Tracking");
    println!("----------------------");

    let vehicle_path = vec![
        TemporalPoint {
            point: Point::new(-74.0060, 40.7128),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-74.0040, 40.7150),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260),
        },
        TemporalPoint {
            point: Point::new(-74.0020, 40.7172),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320),
        },
    ];

    db.insert_trajectory("vehicle:truck001", &vehicle_path, None)?;
    println!(
        "   Stored vehicle trajectory with {} waypoints",
        vehicle_path.len()
    );

    // Query trajectory for time range
    let path_segment = db.query_trajectory("vehicle:truck001", 1640995200, 1640995320)?;
    println!(
        "   Retrieved {} waypoints from trajectory\n",
        path_segment.len()
    );

    // === DATABASE STATS ===
    println!("6. Database Statistics");
    println!("----------------------");

    let stats = db.stats();
    println!("   Total keys stored: {}", stats.key_count);
    println!("   Total operations: {}\n", stats.operations_count);

    // === TTL DEMONSTRATION (LAZY) ===
    println!("7. TTL Expiration (Lazy Deletion)");
    println!("----------------------------------");
    println!("   Waiting 6 seconds for TTL expiration...");
    std::thread::sleep(Duration::from_secs(6));

    match db.get("session:abc")? {
        Some(_) => println!("   Session still active (unexpected)"),
        None => println!("   ✓ Session expired (lazy check on read)"),
    }

    // Manual cleanup
    let removed = db.cleanup_expired()?;
    println!("   Cleaned up {} expired keys from storage\n", removed);

    println!("=== Getting Started Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Simple key-value storage");
    println!("  • Automatic spatial indexing");
    println!("  • Radius-based queries");
    println!("  • Bounding box queries");
    println!("  • Trajectory tracking");
    println!("  • TTL support (lazy expiration + manual cleanup)");
    println!("  • Atomic operations");
    println!("\nNext: Try 'spatial_queries' example for more advanced queries");

    Ok(())
}

examples/comprehensive_demo.rs (line 53)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Spatio - Comprehensive Demo ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // === 1. BASIC KEY-VALUE OPERATIONS ===
    println!("1. Basic Key-Value Operations");
    println!("------------------------------");

    db.insert("app:name", b"Spatio Demo", None)?;
    db.insert("app:version", b"1.0.0", None)?;
    db.insert("user:alice", b"Alice Johnson", None)?;

    let app_name = db.get("app:name")?.unwrap();
    println!("   Stored: {}", String::from_utf8_lossy(&app_name));

    let count = db.stats().key_count;
    println!("   Total keys: {}\n", count);

    // === 2. TTL (TIME-TO-LIVE) ===
    println!("2. TTL (Time-to-Live)");
    println!("---------------------");

    let session_opts = SetOptions::with_ttl(Duration::from_secs(10));
    db.insert("session:temp", b"expires_soon", Some(session_opts))?;
    println!("   Created session with 10-second TTL");

    let cache_opts = SetOptions::with_ttl(Duration::from_secs(300));
    db.insert("cache:weather", b"sunny, 22C", Some(cache_opts))?;
    println!("   Cached data with 5-minute TTL\n");

    // === 3. ATOMIC BATCH OPERATIONS ===
    println!("3. Atomic Batch Operations");
    println!("--------------------------");

    db.atomic(|batch| {
        batch.insert("sensor:temp", b"23.5", None)?;
        batch.insert("sensor:humidity", b"68", None)?;
        batch.insert("sensor:pressure", b"1013", None)?;
        Ok(())
    })?;
    println!("   Atomically inserted 3 sensor readings\n");

    // === 4. SPATIAL POINT STORAGE ===
    println!("4. Spatial Point Storage");
    println!("------------------------");

    let cities = vec![
        ("New York", Point::new(-74.0060, 40.7128)),
        ("London", Point::new(-0.1278, 51.5074)),
        ("Paris", Point::new(2.3522, 48.8566)),
        ("Tokyo", Point::new(139.6503, 35.6762)),
        ("Sydney", Point::new(151.2093, -33.8688)),
    ];

    for (name, point) in &cities {
        db.insert_point("cities", point, name.as_bytes(), None)?;
    }
    println!("   Stored {} cities with spatial indexing", cities.len());

    // Find nearby cities
    let london = Point::new(-0.1278, 51.5074);
    let nearby = db.query_within_radius("cities", &london, 1_000_000.0, 10)?;
    println!("   Cities within 1000km of London: {}", nearby.len());
    for (_, data, _) in &nearby {
        println!("     - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === 5. SPATIAL QUERIES ===
    println!("5. Spatial Query Methods");
    println!("------------------------");

    // Existence check
    let has_nearby = db.intersects_radius("cities", &london, 500_000.0)?;
    println!("   Cities within 500km of London exist: {}", has_nearby);

    // Count points
    let count = db.count_within_radius("cities", &london, 2_000_000.0)?;
    println!("   Cities within 2000km of London: {}", count);

    // Bounding box query (Europe)
    let europe = db.find_within_bounds("cities", -10.0, 40.0, 20.0, 60.0, 10)?;
    println!("   Cities in European bounding box: {}", europe.len());
    for (_point, data) in europe {
        println!("     - {}", String::from_utf8_lossy(&data));
    }
    println!();

    // === 6. POINTS OF INTEREST ===
    println!("6. Multiple Namespaces (POI)");
    println!("----------------------------");

    let landmarks = vec![
        ("Big Ben", Point::new(-0.1245, 51.4994)),
        ("Tower Bridge", Point::new(-0.0754, 51.5055)),
        ("London Eye", Point::new(-0.1195, 51.5033)),
    ];

    for (name, point) in &landmarks {
        db.insert_point("landmarks", point, name.as_bytes(), None)?;
    }
    println!("   Added {} London landmarks", landmarks.len());

    // Query different namespaces
    let nearby_landmarks = db.query_within_radius("landmarks", &london, 5_000.0, 10)?;
    println!(
        "   Landmarks within 5km of London: {}",
        nearby_landmarks.len()
    );
    for (_, data, _) in &nearby_landmarks {
        println!("     - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === 7. TRAJECTORY TRACKING ===
    println!("7. Trajectory Tracking");
    println!("----------------------");

    let delivery_route = vec![
        TemporalPoint {
            point: Point::new(-0.1278, 51.5074),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-0.0931, 51.5055),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260),
        },
        TemporalPoint {
            point: Point::new(-0.0865, 51.5045),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320),
        },
        TemporalPoint {
            point: Point::new(-0.1245, 51.4994),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995380),
        },
    ];

    db.insert_trajectory("delivery:truck001", &delivery_route, None)?;
    println!(
        "   Stored delivery trajectory ({} waypoints)",
        delivery_route.len()
    );

    // Query trajectory for time range
    let path = db.query_trajectory("delivery:truck001", 1640995200, 1640995320)?;
    println!(
        "   Retrieved {} waypoints for first 2 minutes\n",
        path.len()
    );

    // === 8. DATA UPDATES & DELETES ===
    println!("8. Updates and Deletes");
    println!("----------------------");

    // Update existing key
    db.insert("app:version", b"1.0.1", None)?;
    let new_version = db.get("app:version")?.unwrap();
    println!(
        "   Updated version to: {}",
        String::from_utf8_lossy(&new_version)
    );

    // Delete key
    let deleted = db.delete("user:alice")?;
    println!("   Deleted key: {}", deleted.is_some());
    println!();

    // === 9. DATABASE STATISTICS ===
    println!("9. Database Statistics");
    println!("----------------------");

    let stats = db.stats();
    println!("   Total keys: {}", stats.key_count);
    println!("   Total operations: {}\n", stats.operations_count);

    // === 10. TTL EXPIRATION DEMO (LAZY) ===
    println!("10. TTL Expiration (lazy deletion)");
    println!("-----------------------------------");

    std::thread::sleep(Duration::from_secs(11));

    match db.get("session:temp")? {
        Some(_) => println!("   Session still active (unexpected)"),
        None => println!("   ✓ Session expired (lazy check on read)\n"),
    }

    // === 11. MANUAL CLEANUP ===
    println!("11. Manual Cleanup");
    println!("------------------");
    let removed = db.cleanup_expired()?;
    println!("   Removed {} expired keys from storage\n", removed);

    println!("=== Comprehensive Demo Complete! ===");
    println!("\nFeatures Demonstrated:");
    println!("  • Key-value storage");
    println!("  • TTL (lazy expiration + manual cleanup)");
    println!("  • Atomic batch operations");
    println!("  • Spatial point indexing");
    println!("  • Radius queries");
    println!("  • Bounding box queries");
    println!("  • Multiple namespaces");
    println!("  • Trajectory tracking");
    println!("  • Updates and deletes");
    println!("  • Manual expired key cleanup");

    Ok(())
}

examples/spatial_queries.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Spatio - Spatial Queries ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // === SETUP: Insert World Cities ===
    println!("Setting up test data...");

    let cities = vec![
        ("New York", Point::new(-74.0060, 40.7128)),
        ("London", Point::new(-0.1278, 51.5074)),
        ("Paris", Point::new(2.3522, 48.8566)),
        ("Berlin", Point::new(13.4050, 52.5200)),
        ("Madrid", Point::new(-3.7038, 40.4168)),
        ("Rome", Point::new(12.4964, 41.9028)),
        ("Tokyo", Point::new(139.6503, 35.6762)),
        ("Sydney", Point::new(151.2093, -33.8688)),
        ("Mumbai", Point::new(72.8777, 19.0760)),
        ("Cairo", Point::new(31.2357, 30.0444)),
        ("São Paulo", Point::new(-46.6333, -23.5505)),
        ("Mexico City", Point::new(-99.1332, 19.4326)),
    ];

    for (name, point) in &cities {
        db.insert_point("world_cities", point, name.as_bytes(), None)?;
    }
    println!("   Added {} cities to spatial index\n", cities.len());

    // === 1. RADIUS QUERIES ===
    println!("1. Radius-Based Queries (query_within_radius)");
    println!("----------------------------------------------");

    let london = Point::new(-0.1278, 51.5074);

    // Find cities within 500km of London
    let nearby_500km = db.query_within_radius("world_cities", &london, 500_000.0, 10)?;
    println!("   Cities within 500km of London: {}", nearby_500km.len());
    for (_, data, _) in &nearby_500km {
        println!("     - {}", String::from_utf8_lossy(data));
    }

    // Find cities within 2000km of London
    let nearby_2000km = db.query_within_radius("world_cities", &london, 2_000_000.0, 10)?;
    println!(
        "\n   Cities within 2000km of London: {}",
        nearby_2000km.len()
    );
    for (_, data, _) in &nearby_2000km {
        println!("     - {}", String::from_utf8_lossy(data));
    }

    // Use limit to get only closest N cities
    let closest_3 = db.query_within_radius("world_cities", &london, f64::INFINITY, 3)?;
    println!("\n   Closest 3 cities to London:");
    for (i, (_, data, _)) in closest_3.iter().enumerate() {
        println!("     {}. {}", i + 1, String::from_utf8_lossy(data));
    }
    println!();

    // === 2. EXISTENCE CHECKS ===
    println!("2. Existence Checks (contains_point)");
    println!("-------------------------------------");

    let has_nearby_500km = db.intersects_radius("world_cities", &london, 500_000.0)?;
    let has_nearby_100km = db.intersects_radius("world_cities", &london, 100_000.0)?;

    println!("   Any cities within 500km of London? {}", has_nearby_500km);
    println!("   Any cities within 100km of London? {}", has_nearby_100km);

    // === 3. COUNTING POINTS ===
    println!("3. Counting Points (count_within_radius)");
    println!("----------------------------------------");

    let count_500km = db.count_within_radius("world_cities", &london, 500_000.0)?;
    let count_1000km = db.count_within_radius("world_cities", &london, 1_000_000.0)?;
    let count_2000km = db.count_within_radius("world_cities", &london, 2_000_000.0)?;

    println!("   Cities within 500km of London: {}", count_500km);
    println!("   Cities within 1000km of London: {}", count_1000km);
    println!("   Cities within 2000km of London: {}", count_2000km);
    println!();

    // === 4. BOUNDING BOX QUERIES ===
    println!("4. Bounding Box Queries");
    println!("-----------------------");

    // European bounding box (min_lon, min_lat, max_lon, max_lat)
    println!("   European region (lon: -10 to 20, lat: 40 to 60):");
    let europe_cities = db.find_within_bounds("world_cities", -10.0, 40.0, 20.0, 60.0, 20)?;
    println!("     Found {} cities:", europe_cities.len());
    for (point, data) in &europe_cities {
        println!(
            "       - {} at ({:.2}°, {:.2}°)",
            String::from_utf8_lossy(data),
            point.x(),
            point.y()
        );
    }

    // Asia-Pacific region
    println!("\n   Asia-Pacific region (lon: 70 to 180, lat: -40 to 40):");
    let asia_cities = db.find_within_bounds("world_cities", 70.0, -40.0, 180.0, 40.0, 20)?;
    println!("     Found {} cities:", asia_cities.len());
    for (_, data) in &asia_cities {
        println!("       - {}", String::from_utf8_lossy(data));
    }

    // Americas region
    println!("\n   Americas region (lon: -130 to -30, lat: -60 to 60):");
    let americas_cities = db.find_within_bounds("world_cities", -130.0, -60.0, -30.0, 60.0, 20)?;
    println!("     Found {} cities:", americas_cities.len());
    for (_, data) in &americas_cities {
        println!("       - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === 5. BOUNDING BOX INTERSECTION ===
    println!("5. Bounding Box Intersection (intersects_bounds)");
    println!("------------------------------------------------");

    let has_european = db.intersects_bounds("world_cities", -10.0, 40.0, 20.0, 60.0)?;
    let has_antarctica = db.intersects_bounds("world_cities", -180.0, -90.0, 180.0, -60.0)?;

    println!("   European region has cities? {}", has_european);
    println!("   Antarctica region has cities? {}", has_antarctica);
    println!();

    // === 6. MULTIPLE NAMESPACES ===
    println!("6. Multiple Namespaces");
    println!("----------------------");

    // Add some landmarks in London
    let london_landmarks = vec![
        ("Big Ben", Point::new(-0.1245, 51.4994)),
        ("Tower Bridge", Point::new(-0.0754, 51.5055)),
        ("London Eye", Point::new(-0.1195, 51.5033)),
        ("Buckingham Palace", Point::new(-0.1419, 51.5014)),
    ];

    for (name, point) in &london_landmarks {
        db.insert_point("landmarks", point, name.as_bytes(), None)?;
    }

    println!("   Added {} London landmarks", london_landmarks.len());

    // Query different namespaces from same location
    let center_london = Point::new(-0.1278, 51.5074);

    let nearby_cities = db.query_within_radius("world_cities", &center_london, 10_000.0, 10)?;
    let nearby_landmarks = db.query_within_radius("landmarks", &center_london, 10_000.0, 10)?;

    println!("   Within 10km of center London:");
    println!("     Cities: {}", nearby_cities.len());
    println!("     Landmarks: {}", nearby_landmarks.len());

    println!("\n   Landmarks within 2km:");
    let close_landmarks = db.query_within_radius("landmarks", &center_london, 2_000.0, 10)?;
    for (_, data, _) in &close_landmarks {
        println!("     - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === 7. QUERY LIMITS ===
    println!("7. Query Result Limiting");
    println!("------------------------");

    let all_cities = db.query_within_radius("world_cities", &london, f64::INFINITY, 100)?;
    let top_5 = db.query_within_radius("world_cities", &london, f64::INFINITY, 5)?;
    let top_3 = db.query_within_radius("world_cities", &london, f64::INFINITY, 3)?;

    println!("   Total cities in database: {}", all_cities.len());
    println!("   With limit=5: {} cities", top_5.len());
    println!("   With limit=3: {} cities", top_3.len());
    println!();

    // === SUMMARY ===
    let stats = db.stats();
    println!("=== Query Summary ===");
    println!("Database statistics:");
    println!("  Total keys: {}", stats.key_count);
    println!("  Operations: {}", stats.operations_count);

    println!("\nSpatial query methods demonstrated:");
    println!("  • query_within_radius - Find points within distance");
    println!("  • contains_point - Check if points exist in radius");
    println!("  • count_within_radius - Count points efficiently");
    println!("  • find_within_bounds - Rectangular region queries");
    println!("  • intersects_bounds - Check bounding box intersection");
    println!("  • Multiple namespaces - Organize different point types");
    println!("  • Result limiting - Control query result size");

    Ok(())
}

examples/trajectory_tracking.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Spatio - Trajectory Tracking ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // === 1. BASIC TRAJECTORY STORAGE ===
    println!("1. Basic Trajectory Storage");
    println!("---------------------------");

    // Create a simple delivery route
    let delivery_route = vec![
        TemporalPoint {
            point: Point::new(-74.0060, 40.7128), // NYC
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-74.0040, 40.7150),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260), // +1 min
        },
        TemporalPoint {
            point: Point::new(-74.0020, 40.7172),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320), // +2 min
        },
        TemporalPoint {
            point: Point::new(-74.0000, 40.7194),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995380), // +3 min
        },
    ];

    db.insert_trajectory("vehicle:truck001", &delivery_route, None)?;
    println!(
        "   Stored delivery truck trajectory with {} waypoints\n",
        delivery_route.len()
    );

    // === 2. QUERY FULL TRAJECTORY ===
    println!("2. Query Full Trajectory");
    println!("------------------------");

    let full_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995400)?;
    println!("   Retrieved {} waypoints:", full_path.len());
    for (i, tp) in full_path.iter().enumerate() {
        println!(
            "     {}. Point ({:.4}°, {:.4}°) at timestamp {}",
            i + 1,
            tp.point.x(),
            tp.point.y(),
            tp.timestamp.duration_since(UNIX_EPOCH).unwrap().as_secs()
        );
    }
    println!();

    // === 3. QUERY TIME RANGE ===
    println!("3. Query Specific Time Range");
    println!("----------------------------");

    // Get only first 2 minutes of trajectory
    let partial_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995320)?;
    println!("   First 2 minutes: {} waypoints", partial_path.len());

    // Get only middle segment
    let middle_segment = db.query_trajectory("vehicle:truck001", 1640995260, 1640995320)?;
    println!("   Middle segment: {} waypoints\n", middle_segment.len());

    // === 4. MULTIPLE TRAJECTORIES ===
    println!("4. Multiple Trajectories");
    println!("------------------------");

    // Add taxi route
    let taxi_route = vec![
        TemporalPoint {
            point: Point::new(-0.1278, 51.5074), // London
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-0.1195, 51.5033),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260),
        },
        TemporalPoint {
            point: Point::new(-0.1245, 51.4994),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320),
        },
    ];

    db.insert_trajectory("vehicle:taxi042", &taxi_route, None)?;
    println!(
        "   Stored taxi trajectory with {} waypoints",
        taxi_route.len()
    );

    // Add bus route
    let bus_route = vec![
        TemporalPoint {
            point: Point::new(2.3522, 48.8566), // Paris
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(2.3550, 48.8580),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995300),
        },
        TemporalPoint {
            point: Point::new(2.3580, 48.8600),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995400),
        },
        TemporalPoint {
            point: Point::new(2.3610, 48.8620),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995500),
        },
        TemporalPoint {
            point: Point::new(2.3640, 48.8640),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995600),
        },
    ];

    db.insert_trajectory("vehicle:bus123", &bus_route, None)?;
    println!(
        "   Stored bus trajectory with {} waypoints\n",
        bus_route.len()
    );

    // === 5. QUERY DIFFERENT VEHICLES ===
    println!("5. Query Different Vehicles");
    println!("---------------------------");

    let truck_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995400)?;
    let taxi_path = db.query_trajectory("vehicle:taxi042", 1640995200, 1640995400)?;
    let bus_path = db.query_trajectory("vehicle:bus123", 1640995200, 1640995700)?;

    println!("   Truck waypoints: {}", truck_path.len());
    println!("   Taxi waypoints: {}", taxi_path.len());
    println!("   Bus waypoints: {}\n", bus_path.len());

    // === 6. LONG-RUNNING TRAJECTORY ===
    println!("6. Long-Running Trajectory (High Frequency)");
    println!("-------------------------------------------");

    // Simulate a drone with frequent position updates
    let mut drone_path = Vec::new();
    let start_time = 1641000000;

    for i in 0..60 {
        // 60 waypoints, 1 per second
        drone_path.push(TemporalPoint {
            point: Point::new(
                -122.4194 + (i as f64 * 0.0001), // San Francisco area
                37.7749 + (i as f64 * 0.0001),
            ),
            timestamp: UNIX_EPOCH + Duration::from_secs(start_time + i),
        });
    }

    db.insert_trajectory("drone:delivery001", &drone_path, None)?;
    println!(
        "   Stored drone trajectory with {} waypoints",
        drone_path.len()
    );

    // Query specific time window (10 seconds)
    let window = db.query_trajectory("drone:delivery001", start_time, start_time + 10)?;
    println!(
        "   Retrieved 10-second window: {} waypoints\n",
        window.len()
    );

    // === 7. TRAJECTORY UPDATES ===
    println!("7. Trajectory Updates");
    println!("---------------------");

    // Add more waypoints to existing trajectory
    let extended_route = vec![
        TemporalPoint {
            point: Point::new(-74.0060, 40.7128),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-74.0040, 40.7150),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260),
        },
        TemporalPoint {
            point: Point::new(-74.0020, 40.7172),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320),
        },
        TemporalPoint {
            point: Point::new(-74.0000, 40.7194),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995380),
        },
        // New waypoints
        TemporalPoint {
            point: Point::new(-73.9980, 40.7216),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995440),
        },
        TemporalPoint {
            point: Point::new(-73.9960, 40.7238),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995500),
        },
    ];

    db.insert_trajectory("vehicle:truck001", &extended_route, None)?;
    let updated_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995600)?;
    println!(
        "   Extended truck trajectory from 4 to {} waypoints\n",
        updated_path.len()
    );

    // === 8. DATABASE STATISTICS ===
    println!("8. Database Statistics");
    println!("----------------------");

    let stats = db.stats();
    println!("   Total keys in database: {}", stats.key_count);
    println!("   Total operations: {}\n", stats.operations_count);

    // === 9. USE CASES ===
    println!("=== Common Use Cases ===\n");

    println!("Fleet Management:");
    println!("  • Track multiple vehicles in real-time");
    println!("  • Query historical routes for analysis");
    println!("  • Retrieve specific time windows for incidents\n");

    println!("Delivery Tracking:");
    println!("  • Store complete delivery routes");
    println!("  • Query progress during specific periods");
    println!("  • Analyze route efficiency\n");

    println!("Drone Operations:");
    println!("  • High-frequency position updates");
    println!("  • Flight path analysis");
    println!("  • Time-based route queries\n");

    println!("Asset Tracking:");
    println!("  • Monitor movement of valuable items");
    println!("  • Historical location queries");
    println!("  • Route verification\n");

    println!("=== Trajectory Tracking Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Store trajectories with timestamps");
    println!("  • Query full trajectories");
    println!("  • Query specific time ranges");
    println!("  • Track multiple vehicles/objects");
    println!("  • High-frequency updates");
    println!("  • Trajectory extensions/updates");

    Ok(())
}

examples/advanced_spatial.rs (line 26)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Advanced Spatial Operations Demo ===\n");

    // Create an in-memory database
    let mut db = Spatio::memory()?;

    // ========================================
    // 1. Distance Calculations
    // ========================================
    println!("1. Distance Calculations");
    println!("{}", "=".repeat(50));

    let new_york = Point::new(-74.0060, 40.7128);
    let los_angeles = Point::new(-118.2437, 34.0522);
    let london = Point::new(-0.1278, 51.5074);

    // Calculate distances using different metrics
    let dist_haversine = distance_between(&new_york, &los_angeles, DistanceMetric::Haversine);
    let dist_geodesic = distance_between(&new_york, &los_angeles, DistanceMetric::Geodesic);
    let dist_rhumb = distance_between(&new_york, &los_angeles, DistanceMetric::Rhumb);

    println!("NYC to LA:");
    println!("  Haversine:  {:.2} km", dist_haversine / 1000.0);
    println!("  Geodesic:   {:.2} km", dist_geodesic / 1000.0);
    println!("  Rhumb:      {:.2} km", dist_rhumb / 1000.0);

    // Using the database method
    let db_distance = db.distance_between(&new_york, &london, DistanceMetric::Haversine)?;
    println!("\nNYC to London: {:.2} km", db_distance / 1000.0);

    // ========================================
    // 2. K-Nearest-Neighbors (KNN)
    // ========================================
    println!("\n2. K-Nearest-Neighbors Query");
    println!("{}", "=".repeat(50));

    // Insert major cities
    let cities = vec![
        (Point::new(-74.0060, 40.7128), "New York", "USA"),
        (Point::new(-118.2437, 34.0522), "Los Angeles", "USA"),
        (Point::new(-87.6298, 41.8781), "Chicago", "USA"),
        (Point::new(-95.3698, 29.7604), "Houston", "USA"),
        (Point::new(-75.1652, 39.9526), "Philadelphia", "USA"),
        (Point::new(-122.4194, 37.7749), "San Francisco", "USA"),
        (Point::new(-0.1278, 51.5074), "London", "UK"),
        (Point::new(2.3522, 48.8566), "Paris", "France"),
        (Point::new(139.6917, 35.6895), "Tokyo", "Japan"),
    ];

    for (point, name, country) in &cities {
        let data = format!("{},{}", name, country);
        db.insert_point("world_cities", point, data.as_bytes(), None)?;
    }

    // Find 3 nearest cities to a query point (somewhere in New Jersey)
    let query_point = Point::new(-74.1719, 40.7357);
    let nearest = db.knn(
        "world_cities",
        &query_point,
        3,
        500_000.0, // Search within 500km
        DistanceMetric::Haversine,
    )?;

    println!("3 nearest cities to query point:");
    for (i, (_point, data, distance)) in nearest.iter().enumerate() {
        let city_info = String::from_utf8_lossy(data);
        println!(
            "  {}. {} ({:.2} km away)",
            i + 1,
            city_info,
            distance / 1000.0
        );
    }

    // ========================================
    // 3. Polygon Queries
    // ========================================
    println!("\n3. Polygon Queries");
    println!("{}", "=".repeat(50));

    // Define a polygon covering parts of the eastern US
    use geo::polygon;
    let east_coast_polygon = polygon![
        (x: -80.0, y: 35.0),  // South
        (x: -70.0, y: 35.0),  // Southeast
        (x: -70.0, y: 45.0),  // Northeast
        (x: -80.0, y: 45.0),  // Northwest
        (x: -80.0, y: 35.0),  // Close the polygon
    ];
    let east_coast_polygon: Polygon = east_coast_polygon.into();

    let cities_in_polygon = db.query_within_polygon("world_cities", &east_coast_polygon, 100)?;

    println!("Cities within East Coast polygon:");
    for (point, data) in &cities_in_polygon {
        let city_info = String::from_utf8_lossy(data);
        println!("  - {} at ({:.4}, {:.4})", city_info, point.x(), point.y());
    }

    // ========================================
    // 4. Bounding Box Operations
    // ========================================
    println!("\n4. Bounding Box Operations");
    println!("{}", "=".repeat(50));

    // Create a bounding box around the New York area
    let ny_bbox = bounding_box(-74.5, 40.5, -73.5, 41.0)?;
    println!("NY Area Bounding Box: {:?}", ny_bbox);

    // Find cities in bounding box
    let cities_in_bbox = db.find_within_bounds("world_cities", 40.5, -74.5, 41.0, -73.5, 100)?;
    println!("\nCities in NY area bounding box:");
    for (_point, data) in &cities_in_bbox {
        let city_info = String::from_utf8_lossy(data);
        println!("  - {}", city_info);
    }

    // ========================================
    // 5. Convex Hull
    // ========================================
    println!("\n5. Convex Hull Calculation");
    println!("{}", "=".repeat(50));

    // Get all city points
    let city_points: Vec<Point> = cities.iter().map(|(p, _, _)| *p).collect();

    // Calculate convex hull
    if let Some(hull) = convex_hull(&city_points) {
        println!("Convex hull of all cities:");
        println!("  Exterior points: {}", hull.exterior().0.len() - 1);
        for coord in hull.exterior().0.iter().take(5) {
            println!("    ({:.4}, {:.4})", coord.x, coord.y);
        }
    }

    // ========================================
    // 6. Bounding Rectangle
    // ========================================
    println!("\n6. Bounding Rectangle");
    println!("{}", "=".repeat(50));

    if let Some(bbox) = bounding_rect_for_points(&city_points) {
        println!("Bounding rectangle of all cities:");
        println!("  Min: ({:.4}, {:.4})", bbox.min().x, bbox.min().y);
        println!("  Max: ({:.4}, {:.4})", bbox.max().x, bbox.max().y);
        println!("  Width:  {:.2}°", bbox.max().x - bbox.min().x);
        println!("  Height: {:.2}°", bbox.max().y - bbox.min().y);
    }

    // ========================================
    // 7. Advanced Radius Queries
    // ========================================
    println!("\n7. Advanced Radius Queries");
    println!("{}", "=".repeat(50));

    // Count cities within 1000km of NYC
    let count = db.count_within_radius("world_cities", &new_york, 1_000_000.0)?;
    println!("Cities within 1000km of NYC: {}", count);

    // Check if any cities exist within 100km
    let has_nearby = db.intersects_radius("world_cities", &new_york, 100_000.0)?;
    println!("Has cities within 100km of NYC: {}", has_nearby);

    // Query with radius
    let nearby = db.query_within_radius("world_cities", &new_york, 200_000.0, 10)?;
    println!("\nCities within 200km of NYC:");
    for (point, data, _distance) in &nearby {
        let city_info = String::from_utf8_lossy(data);
        let dist = distance_between(&new_york, point, DistanceMetric::Haversine);
        println!("  - {} ({:.2} km)", city_info, dist / 1000.0);
    }

    // ========================================
    // 8. Spatial Analytics
    // ========================================
    println!("\n8. Spatial Analytics");
    println!("{}", "=".repeat(50));

    // Find the two most distant cities (brute force)
    let mut max_distance = 0.0;
    let mut furthest_pair = ("", "");

    for (i, (p1, n1, _)) in cities.iter().enumerate() {
        for (p2, n2, _) in cities.iter().skip(i + 1) {
            let dist = distance_between(p1, p2, DistanceMetric::Geodesic);
            if dist > max_distance {
                max_distance = dist;
                furthest_pair = (n1, n2);
            }
        }
    }

    println!(
        "Most distant city pair: {} ↔ {}",
        furthest_pair.0, furthest_pair.1
    );
    println!("Distance: {:.2} km", max_distance / 1000.0);

    // Calculate average distance between all US cities
    let us_cities: Vec<_> = cities
        .iter()
        .filter(|(_, _, country)| *country == "USA")
        .collect();

    if us_cities.len() > 1 {
        let mut total_distance = 0.0;
        let mut count = 0;

        for (i, (p1, _, _)) in us_cities.iter().enumerate() {
            for (p2, _, _) in us_cities.iter().skip(i + 1) {
                total_distance += distance_between(p1, p2, DistanceMetric::Haversine);
                count += 1;
            }
        }

        let avg_distance = total_distance / count as f64;
        println!(
            "\nAverage distance between US cities: {:.2} km",
            avg_distance / 1000.0
        );
    }

    // ========================================
    // Summary
    // ========================================
    println!("\n{}", "=".repeat(50));
    println!("Summary:");
    println!("  - Demonstrated multiple distance metrics");
    println!("  - Performed K-nearest-neighbor searches");
    println!("  - Queried points within polygons");
    println!("  - Used bounding box operations");
    println!("  - Calculated convex hulls");
    println!("  - Performed spatial analytics");
    println!("\nAll spatial operations leverage the geo crate!");

    Ok(())
}

examples/bbox_database.rs (line 64)

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Spatio - Bounding Box Database ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // ========================================
    // 1. Store Geographic Regions
    // ========================================
    println!("1. Storing Geographic Regions");
    println!("------------------------------");

    // Define NYC boroughs as bounding boxes
    let manhattan = BoundingBox2D::new(-74.0479, 40.6829, -73.9067, 40.8820);
    let brooklyn = BoundingBox2D::new(-74.0421, 40.5707, -73.8333, 40.7395);
    let queens = BoundingBox2D::new(-73.9626, 40.5431, -73.7004, 40.8007);
    let bronx = BoundingBox2D::new(-73.9338, 40.7855, -73.7654, 40.9176);
    let staten_island = BoundingBox2D::new(-74.2558, 40.4960, -74.0526, 40.6490);

    // Store regions in database
    db.insert_bbox("region:manhattan", &manhattan, None)?;
    db.insert_bbox("region:brooklyn", &brooklyn, None)?;
    db.insert_bbox("region:queens", &queens, None)?;
    db.insert_bbox("region:bronx", &bronx, None)?;
    db.insert_bbox("region:staten_island", &staten_island, None)?;

    println!("   ✓ Stored 5 NYC borough boundaries");

    // ========================================
    // 2. Retrieve Stored Regions
    // ========================================
    println!("\n2. Retrieving Stored Regions");
    println!("-----------------------------");

    if let Some(retrieved_manhattan) = db.get_bbox("region:manhattan")? {
        println!("   Manhattan:");
        println!(
            "     Area: {:.4}° × {:.4}°",
            retrieved_manhattan.width(),
            retrieved_manhattan.height()
        );
        println!(
            "     Center: ({:.4}, {:.4})",
            retrieved_manhattan.center().x(),
            retrieved_manhattan.center().y()
        );
    }

    // ========================================
    // 3. Store POIs and Query by Region
    // ========================================
    println!("\n3. Store POIs and Query by Region");
    println!("-----------------------------------");

    // Store points of interest
    db.insert_point("poi", &Point::new(-73.9855, 40.7580), b"times_square", None)?;
    db.insert_point("poi", &Point::new(-73.9665, 40.7829), b"central_park", None)?;
    db.insert_point("poi", &Point::new(-73.9857, 40.7484), b"empire_state", None)?;
    db.insert_point(
        "poi",
        &Point::new(-73.9969, 40.7061),
        b"brooklyn_bridge",
        None,
    )?;
    db.insert_point(
        "poi",
        &Point::new(-73.9690, 40.6602),
        b"prospect_park",
        None,
    )?;
    db.insert_point("poi", &Point::new(-73.9799, 40.5755), b"coney_island", None)?;

    println!("   ✓ Stored 6 points of interest");

    // Query POIs in Manhattan
    let manhattan_pois = db.query_within_bbox("poi", &manhattan, 100)?;
    println!("\n   POIs in Manhattan: {}", manhattan_pois.len());
    for (point, data) in &manhattan_pois {
        let name = String::from_utf8_lossy(data);
        println!("     - {} at ({:.4}, {:.4})", name, point.x(), point.y());
    }

    // Query POIs in Brooklyn
    let brooklyn_pois = db.query_within_bbox("poi", &brooklyn, 100)?;
    println!("\n   POIs in Brooklyn: {}", brooklyn_pois.len());

    // ========================================
    // 4. Find Intersecting Regions
    // ========================================
    println!("\n4. Finding Intersecting Regions");
    println!("--------------------------------");

    // Create a search area (covering parts of Manhattan and Queens)
    let search_area = BoundingBox2D::new(-73.98, 40.72, -73.92, 40.78);

    let intersecting = db.find_intersecting_bboxes("region:", &search_area)?;
    println!(
        "   Search area intersects with {} boroughs:",
        intersecting.len()
    );
    for (key, _bbox) in &intersecting {
        println!("     - {}", key.replace("region:", ""));
    }

    // ========================================
    // 5. Delivery Zone Management
    // ========================================
    println!("\n5. Delivery Zone Management");
    println!("----------------------------");

    // Define delivery zones
    let zone_a = BoundingBox2D::new(-74.02, 40.70, -73.98, 40.74);
    let zone_b = BoundingBox2D::new(-74.00, 40.72, -73.96, 40.76);
    let zone_c = BoundingBox2D::new(-73.98, 40.74, -73.94, 40.78);

    db.insert_bbox("delivery:zone_a", &zone_a, None)?;
    db.insert_bbox("delivery:zone_b", &zone_b, None)?;
    db.insert_bbox("delivery:zone_c", &zone_c, None)?;

    println!("   ✓ Created 3 delivery zones");

    // Check which zones overlap
    let overlapping_with_a = db.find_intersecting_bboxes("delivery:", &zone_a)?;
    println!(
        "\n   Zone A overlaps with {} zones (including itself)",
        overlapping_with_a.len()
    );

    // ========================================
    // 6. Service Area Lookup
    // ========================================
    println!("\n6. Service Area Lookup");
    println!("-----------------------");

    // Check if various locations are in service areas
    let locations = vec![
        ("Customer 1", Point::new(-74.00, 40.72)),
        ("Customer 2", Point::new(-73.97, 40.75)),
        ("Customer 3", Point::new(-74.05, 40.68)),
    ];

    for (name, location) in &locations {
        let mut in_zone = false;
        for (zone_key, zone_bbox) in &overlapping_with_a {
            if zone_bbox.contains_point(location) {
                println!(
                    "   {} at ({:.4}, {:.4}) is in {}",
                    name,
                    location.x(),
                    location.y(),
                    zone_key.replace("delivery:", "")
                );
                in_zone = true;
                break;
            }
        }
        if !in_zone {
            println!(
                "   {} at ({:.4}, {:.4}) is outside all zones",
                name,
                location.x(),
                location.y()
            );
        }
    }

    // ========================================
    // 7. Geofencing Example
    // ========================================
    println!("\n7. Geofencing Example");
    println!("----------------------");

    // Define restricted areas
    let airport_zone = BoundingBox2D::new(-73.82, 40.63, -73.76, 40.66);
    db.insert_bbox("restricted:jfk_airport", &airport_zone, None)?;

    let military_zone = BoundingBox2D::new(-74.08, 40.60, -74.03, 40.64);
    db.insert_bbox("restricted:military", &military_zone, None)?;

    println!("   ✓ Defined 2 restricted zones");

    // Check if drone locations are in restricted areas
    let drone_locations = vec![
        ("Drone 1", Point::new(-73.79, 40.64)),
        ("Drone 2", Point::new(-74.00, 40.70)),
    ];

    for (drone, location) in &drone_locations {
        let restricted = db.find_intersecting_bboxes(
            "restricted:",
            &BoundingBox2D::new(
                location.x() - 0.001,
                location.y() - 0.001,
                location.x() + 0.001,
                location.y() + 0.001,
            ),
        )?;

        if !restricted.is_empty() {
            println!(
                "   ⚠ {} at ({:.4}, {:.4}) is in restricted area: {}",
                drone,
                location.x(),
                location.y(),
                restricted[0].0.replace("restricted:", "")
            );
        } else {
            println!(
                "   ✓ {} at ({:.4}, {:.4}) is in safe area",
                drone,
                location.x(),
                location.y()
            );
        }
    }

    // ========================================
    // 8. Spatial Analytics
    // ========================================
    println!("\n8. Spatial Analytics");
    println!("---------------------");

    // Calculate coverage area
    let mut total_width = 0.0;
    let mut total_height = 0.0;
    let mut count = 0;

    let all_regions = vec![
        ("Manhattan", &manhattan),
        ("Brooklyn", &brooklyn),
        ("Queens", &queens),
        ("Bronx", &bronx),
        ("Staten Island", &staten_island),
    ];

    for (name, bbox) in &all_regions {
        total_width += bbox.width();
        total_height += bbox.height();
        count += 1;
        println!(
            "   {} coverage: {:.4}° × {:.4}°",
            name,
            bbox.width(),
            bbox.height()
        );
    }

    let avg_width = total_width / count as f64;
    let avg_height = total_height / count as f64;

    println!(
        "\n   Average borough size: {:.4}° × {:.4}°",
        avg_width, avg_height
    );

    // ========================================
    // 9. Database Statistics
    // ========================================
    println!("\n9. Database Statistics");
    println!("-----------------------");

    let stats = db.stats();
    println!("   Total keys: {}", stats.key_count);
    println!("   Total operations: {}", stats.operations_count);

    // Count different types of data
    let poi_count = manhattan_pois.len() + brooklyn_pois.len();
    println!("   Stored POIs: {}", poi_count);
    println!("   Stored regions: 5");
    println!("   Delivery zones: 3");
    println!("   Restricted zones: 2");

    println!("\n=== Bounding Box Database Integration Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Store and retrieve bounding boxes");
    println!("  • Query POIs within regions");
    println!("  • Find intersecting regions");
    println!("  • Delivery zone management");
    println!("  • Service area lookups");
    println!("  • Geofencing and restricted areas");
    println!("  • Spatial analytics");

    Ok(())
}

Additional examples can be found in:

• examples/bounding_boxes.rs

pub fn x(&self) -> f64

Get the x coordinate (longitude).

Examples found in repository

examples/spatial_queries.rs (line 98)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Spatio - Spatial Queries ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // === SETUP: Insert World Cities ===
    println!("Setting up test data...");

    let cities = vec![
        ("New York", Point::new(-74.0060, 40.7128)),
        ("London", Point::new(-0.1278, 51.5074)),
        ("Paris", Point::new(2.3522, 48.8566)),
        ("Berlin", Point::new(13.4050, 52.5200)),
        ("Madrid", Point::new(-3.7038, 40.4168)),
        ("Rome", Point::new(12.4964, 41.9028)),
        ("Tokyo", Point::new(139.6503, 35.6762)),
        ("Sydney", Point::new(151.2093, -33.8688)),
        ("Mumbai", Point::new(72.8777, 19.0760)),
        ("Cairo", Point::new(31.2357, 30.0444)),
        ("São Paulo", Point::new(-46.6333, -23.5505)),
        ("Mexico City", Point::new(-99.1332, 19.4326)),
    ];

    for (name, point) in &cities {
        db.insert_point("world_cities", point, name.as_bytes(), None)?;
    }
    println!("   Added {} cities to spatial index\n", cities.len());

    // === 1. RADIUS QUERIES ===
    println!("1. Radius-Based Queries (query_within_radius)");
    println!("----------------------------------------------");

    let london = Point::new(-0.1278, 51.5074);

    // Find cities within 500km of London
    let nearby_500km = db.query_within_radius("world_cities", &london, 500_000.0, 10)?;
    println!("   Cities within 500km of London: {}", nearby_500km.len());
    for (_, data, _) in &nearby_500km {
        println!("     - {}", String::from_utf8_lossy(data));
    }

    // Find cities within 2000km of London
    let nearby_2000km = db.query_within_radius("world_cities", &london, 2_000_000.0, 10)?;
    println!(
        "\n   Cities within 2000km of London: {}",
        nearby_2000km.len()
    );
    for (_, data, _) in &nearby_2000km {
        println!("     - {}", String::from_utf8_lossy(data));
    }

    // Use limit to get only closest N cities
    let closest_3 = db.query_within_radius("world_cities", &london, f64::INFINITY, 3)?;
    println!("\n   Closest 3 cities to London:");
    for (i, (_, data, _)) in closest_3.iter().enumerate() {
        println!("     {}. {}", i + 1, String::from_utf8_lossy(data));
    }
    println!();

    // === 2. EXISTENCE CHECKS ===
    println!("2. Existence Checks (contains_point)");
    println!("-------------------------------------");

    let has_nearby_500km = db.intersects_radius("world_cities", &london, 500_000.0)?;
    let has_nearby_100km = db.intersects_radius("world_cities", &london, 100_000.0)?;

    println!("   Any cities within 500km of London? {}", has_nearby_500km);
    println!("   Any cities within 100km of London? {}", has_nearby_100km);

    // === 3. COUNTING POINTS ===
    println!("3. Counting Points (count_within_radius)");
    println!("----------------------------------------");

    let count_500km = db.count_within_radius("world_cities", &london, 500_000.0)?;
    let count_1000km = db.count_within_radius("world_cities", &london, 1_000_000.0)?;
    let count_2000km = db.count_within_radius("world_cities", &london, 2_000_000.0)?;

    println!("   Cities within 500km of London: {}", count_500km);
    println!("   Cities within 1000km of London: {}", count_1000km);
    println!("   Cities within 2000km of London: {}", count_2000km);
    println!();

    // === 4. BOUNDING BOX QUERIES ===
    println!("4. Bounding Box Queries");
    println!("-----------------------");

    // European bounding box (min_lon, min_lat, max_lon, max_lat)
    println!("   European region (lon: -10 to 20, lat: 40 to 60):");
    let europe_cities = db.find_within_bounds("world_cities", -10.0, 40.0, 20.0, 60.0, 20)?;
    println!("     Found {} cities:", europe_cities.len());
    for (point, data) in &europe_cities {
        println!(
            "       - {} at ({:.2}°, {:.2}°)",
            String::from_utf8_lossy(data),
            point.x(),
            point.y()
        );
    }

    // Asia-Pacific region
    println!("\n   Asia-Pacific region (lon: 70 to 180, lat: -40 to 40):");
    let asia_cities = db.find_within_bounds("world_cities", 70.0, -40.0, 180.0, 40.0, 20)?;
    println!("     Found {} cities:", asia_cities.len());
    for (_, data) in &asia_cities {
        println!("       - {}", String::from_utf8_lossy(data));
    }

    // Americas region
    println!("\n   Americas region (lon: -130 to -30, lat: -60 to 60):");
    let americas_cities = db.find_within_bounds("world_cities", -130.0, -60.0, -30.0, 60.0, 20)?;
    println!("     Found {} cities:", americas_cities.len());
    for (_, data) in &americas_cities {
        println!("       - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === 5. BOUNDING BOX INTERSECTION ===
    println!("5. Bounding Box Intersection (intersects_bounds)");
    println!("------------------------------------------------");

    let has_european = db.intersects_bounds("world_cities", -10.0, 40.0, 20.0, 60.0)?;
    let has_antarctica = db.intersects_bounds("world_cities", -180.0, -90.0, 180.0, -60.0)?;

    println!("   European region has cities? {}", has_european);
    println!("   Antarctica region has cities? {}", has_antarctica);
    println!();

    // === 6. MULTIPLE NAMESPACES ===
    println!("6. Multiple Namespaces");
    println!("----------------------");

    // Add some landmarks in London
    let london_landmarks = vec![
        ("Big Ben", Point::new(-0.1245, 51.4994)),
        ("Tower Bridge", Point::new(-0.0754, 51.5055)),
        ("London Eye", Point::new(-0.1195, 51.5033)),
        ("Buckingham Palace", Point::new(-0.1419, 51.5014)),
    ];

    for (name, point) in &london_landmarks {
        db.insert_point("landmarks", point, name.as_bytes(), None)?;
    }

    println!("   Added {} London landmarks", london_landmarks.len());

    // Query different namespaces from same location
    let center_london = Point::new(-0.1278, 51.5074);

    let nearby_cities = db.query_within_radius("world_cities", &center_london, 10_000.0, 10)?;
    let nearby_landmarks = db.query_within_radius("landmarks", &center_london, 10_000.0, 10)?;

    println!("   Within 10km of center London:");
    println!("     Cities: {}", nearby_cities.len());
    println!("     Landmarks: {}", nearby_landmarks.len());

    println!("\n   Landmarks within 2km:");
    let close_landmarks = db.query_within_radius("landmarks", &center_london, 2_000.0, 10)?;
    for (_, data, _) in &close_landmarks {
        println!("     - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === 7. QUERY LIMITS ===
    println!("7. Query Result Limiting");
    println!("------------------------");

    let all_cities = db.query_within_radius("world_cities", &london, f64::INFINITY, 100)?;
    let top_5 = db.query_within_radius("world_cities", &london, f64::INFINITY, 5)?;
    let top_3 = db.query_within_radius("world_cities", &london, f64::INFINITY, 3)?;

    println!("   Total cities in database: {}", all_cities.len());
    println!("   With limit=5: {} cities", top_5.len());
    println!("   With limit=3: {} cities", top_3.len());
    println!();

    // === SUMMARY ===
    let stats = db.stats();
    println!("=== Query Summary ===");
    println!("Database statistics:");
    println!("  Total keys: {}", stats.key_count);
    println!("  Operations: {}", stats.operations_count);

    println!("\nSpatial query methods demonstrated:");
    println!("  • query_within_radius - Find points within distance");
    println!("  • contains_point - Check if points exist in radius");
    println!("  • count_within_radius - Count points efficiently");
    println!("  • find_within_bounds - Rectangular region queries");
    println!("  • intersects_bounds - Check bounding box intersection");
    println!("  • Multiple namespaces - Organize different point types");
    println!("  • Result limiting - Control query result size");

    Ok(())
}

examples/trajectory_tracking.rs (line 50)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Spatio - Trajectory Tracking ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // === 1. BASIC TRAJECTORY STORAGE ===
    println!("1. Basic Trajectory Storage");
    println!("---------------------------");

    // Create a simple delivery route
    let delivery_route = vec![
        TemporalPoint {
            point: Point::new(-74.0060, 40.7128), // NYC
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-74.0040, 40.7150),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260), // +1 min
        },
        TemporalPoint {
            point: Point::new(-74.0020, 40.7172),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320), // +2 min
        },
        TemporalPoint {
            point: Point::new(-74.0000, 40.7194),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995380), // +3 min
        },
    ];

    db.insert_trajectory("vehicle:truck001", &delivery_route, None)?;
    println!(
        "   Stored delivery truck trajectory with {} waypoints\n",
        delivery_route.len()
    );

    // === 2. QUERY FULL TRAJECTORY ===
    println!("2. Query Full Trajectory");
    println!("------------------------");

    let full_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995400)?;
    println!("   Retrieved {} waypoints:", full_path.len());
    for (i, tp) in full_path.iter().enumerate() {
        println!(
            "     {}. Point ({:.4}°, {:.4}°) at timestamp {}",
            i + 1,
            tp.point.x(),
            tp.point.y(),
            tp.timestamp.duration_since(UNIX_EPOCH).unwrap().as_secs()
        );
    }
    println!();

    // === 3. QUERY TIME RANGE ===
    println!("3. Query Specific Time Range");
    println!("----------------------------");

    // Get only first 2 minutes of trajectory
    let partial_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995320)?;
    println!("   First 2 minutes: {} waypoints", partial_path.len());

    // Get only middle segment
    let middle_segment = db.query_trajectory("vehicle:truck001", 1640995260, 1640995320)?;
    println!("   Middle segment: {} waypoints\n", middle_segment.len());

    // === 4. MULTIPLE TRAJECTORIES ===
    println!("4. Multiple Trajectories");
    println!("------------------------");

    // Add taxi route
    let taxi_route = vec![
        TemporalPoint {
            point: Point::new(-0.1278, 51.5074), // London
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-0.1195, 51.5033),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260),
        },
        TemporalPoint {
            point: Point::new(-0.1245, 51.4994),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320),
        },
    ];

    db.insert_trajectory("vehicle:taxi042", &taxi_route, None)?;
    println!(
        "   Stored taxi trajectory with {} waypoints",
        taxi_route.len()
    );

    // Add bus route
    let bus_route = vec![
        TemporalPoint {
            point: Point::new(2.3522, 48.8566), // Paris
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(2.3550, 48.8580),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995300),
        },
        TemporalPoint {
            point: Point::new(2.3580, 48.8600),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995400),
        },
        TemporalPoint {
            point: Point::new(2.3610, 48.8620),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995500),
        },
        TemporalPoint {
            point: Point::new(2.3640, 48.8640),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995600),
        },
    ];

    db.insert_trajectory("vehicle:bus123", &bus_route, None)?;
    println!(
        "   Stored bus trajectory with {} waypoints\n",
        bus_route.len()
    );

    // === 5. QUERY DIFFERENT VEHICLES ===
    println!("5. Query Different Vehicles");
    println!("---------------------------");

    let truck_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995400)?;
    let taxi_path = db.query_trajectory("vehicle:taxi042", 1640995200, 1640995400)?;
    let bus_path = db.query_trajectory("vehicle:bus123", 1640995200, 1640995700)?;

    println!("   Truck waypoints: {}", truck_path.len());
    println!("   Taxi waypoints: {}", taxi_path.len());
    println!("   Bus waypoints: {}\n", bus_path.len());

    // === 6. LONG-RUNNING TRAJECTORY ===
    println!("6. Long-Running Trajectory (High Frequency)");
    println!("-------------------------------------------");

    // Simulate a drone with frequent position updates
    let mut drone_path = Vec::new();
    let start_time = 1641000000;

    for i in 0..60 {
        // 60 waypoints, 1 per second
        drone_path.push(TemporalPoint {
            point: Point::new(
                -122.4194 + (i as f64 * 0.0001), // San Francisco area
                37.7749 + (i as f64 * 0.0001),
            ),
            timestamp: UNIX_EPOCH + Duration::from_secs(start_time + i),
        });
    }

    db.insert_trajectory("drone:delivery001", &drone_path, None)?;
    println!(
        "   Stored drone trajectory with {} waypoints",
        drone_path.len()
    );

    // Query specific time window (10 seconds)
    let window = db.query_trajectory("drone:delivery001", start_time, start_time + 10)?;
    println!(
        "   Retrieved 10-second window: {} waypoints\n",
        window.len()
    );

    // === 7. TRAJECTORY UPDATES ===
    println!("7. Trajectory Updates");
    println!("---------------------");

    // Add more waypoints to existing trajectory
    let extended_route = vec![
        TemporalPoint {
            point: Point::new(-74.0060, 40.7128),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-74.0040, 40.7150),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260),
        },
        TemporalPoint {
            point: Point::new(-74.0020, 40.7172),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320),
        },
        TemporalPoint {
            point: Point::new(-74.0000, 40.7194),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995380),
        },
        // New waypoints
        TemporalPoint {
            point: Point::new(-73.9980, 40.7216),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995440),
        },
        TemporalPoint {
            point: Point::new(-73.9960, 40.7238),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995500),
        },
    ];

    db.insert_trajectory("vehicle:truck001", &extended_route, None)?;
    let updated_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995600)?;
    println!(
        "   Extended truck trajectory from 4 to {} waypoints\n",
        updated_path.len()
    );

    // === 8. DATABASE STATISTICS ===
    println!("8. Database Statistics");
    println!("----------------------");

    let stats = db.stats();
    println!("   Total keys in database: {}", stats.key_count);
    println!("   Total operations: {}\n", stats.operations_count);

    // === 9. USE CASES ===
    println!("=== Common Use Cases ===\n");

    println!("Fleet Management:");
    println!("  • Track multiple vehicles in real-time");
    println!("  • Query historical routes for analysis");
    println!("  • Retrieve specific time windows for incidents\n");

    println!("Delivery Tracking:");
    println!("  • Store complete delivery routes");
    println!("  • Query progress during specific periods");
    println!("  • Analyze route efficiency\n");

    println!("Drone Operations:");
    println!("  • High-frequency position updates");
    println!("  • Flight path analysis");
    println!("  • Time-based route queries\n");

    println!("Asset Tracking:");
    println!("  • Monitor movement of valuable items");
    println!("  • Historical location queries");
    println!("  • Route verification\n");

    println!("=== Trajectory Tracking Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Store trajectories with timestamps");
    println!("  • Query full trajectories");
    println!("  • Query specific time ranges");
    println!("  • Track multiple vehicles/objects");
    println!("  • High-frequency updates");
    println!("  • Trajectory extensions/updates");

    Ok(())
}

examples/advanced_spatial.rs (line 111)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Advanced Spatial Operations Demo ===\n");

    // Create an in-memory database
    let mut db = Spatio::memory()?;

    // ========================================
    // 1. Distance Calculations
    // ========================================
    println!("1. Distance Calculations");
    println!("{}", "=".repeat(50));

    let new_york = Point::new(-74.0060, 40.7128);
    let los_angeles = Point::new(-118.2437, 34.0522);
    let london = Point::new(-0.1278, 51.5074);

    // Calculate distances using different metrics
    let dist_haversine = distance_between(&new_york, &los_angeles, DistanceMetric::Haversine);
    let dist_geodesic = distance_between(&new_york, &los_angeles, DistanceMetric::Geodesic);
    let dist_rhumb = distance_between(&new_york, &los_angeles, DistanceMetric::Rhumb);

    println!("NYC to LA:");
    println!("  Haversine:  {:.2} km", dist_haversine / 1000.0);
    println!("  Geodesic:   {:.2} km", dist_geodesic / 1000.0);
    println!("  Rhumb:      {:.2} km", dist_rhumb / 1000.0);

    // Using the database method
    let db_distance = db.distance_between(&new_york, &london, DistanceMetric::Haversine)?;
    println!("\nNYC to London: {:.2} km", db_distance / 1000.0);

    // ========================================
    // 2. K-Nearest-Neighbors (KNN)
    // ========================================
    println!("\n2. K-Nearest-Neighbors Query");
    println!("{}", "=".repeat(50));

    // Insert major cities
    let cities = vec![
        (Point::new(-74.0060, 40.7128), "New York", "USA"),
        (Point::new(-118.2437, 34.0522), "Los Angeles", "USA"),
        (Point::new(-87.6298, 41.8781), "Chicago", "USA"),
        (Point::new(-95.3698, 29.7604), "Houston", "USA"),
        (Point::new(-75.1652, 39.9526), "Philadelphia", "USA"),
        (Point::new(-122.4194, 37.7749), "San Francisco", "USA"),
        (Point::new(-0.1278, 51.5074), "London", "UK"),
        (Point::new(2.3522, 48.8566), "Paris", "France"),
        (Point::new(139.6917, 35.6895), "Tokyo", "Japan"),
    ];

    for (point, name, country) in &cities {
        let data = format!("{},{}", name, country);
        db.insert_point("world_cities", point, data.as_bytes(), None)?;
    }

    // Find 3 nearest cities to a query point (somewhere in New Jersey)
    let query_point = Point::new(-74.1719, 40.7357);
    let nearest = db.knn(
        "world_cities",
        &query_point,
        3,
        500_000.0, // Search within 500km
        DistanceMetric::Haversine,
    )?;

    println!("3 nearest cities to query point:");
    for (i, (_point, data, distance)) in nearest.iter().enumerate() {
        let city_info = String::from_utf8_lossy(data);
        println!(
            "  {}. {} ({:.2} km away)",
            i + 1,
            city_info,
            distance / 1000.0
        );
    }

    // ========================================
    // 3. Polygon Queries
    // ========================================
    println!("\n3. Polygon Queries");
    println!("{}", "=".repeat(50));

    // Define a polygon covering parts of the eastern US
    use geo::polygon;
    let east_coast_polygon = polygon![
        (x: -80.0, y: 35.0),  // South
        (x: -70.0, y: 35.0),  // Southeast
        (x: -70.0, y: 45.0),  // Northeast
        (x: -80.0, y: 45.0),  // Northwest
        (x: -80.0, y: 35.0),  // Close the polygon
    ];
    let east_coast_polygon: Polygon = east_coast_polygon.into();

    let cities_in_polygon = db.query_within_polygon("world_cities", &east_coast_polygon, 100)?;

    println!("Cities within East Coast polygon:");
    for (point, data) in &cities_in_polygon {
        let city_info = String::from_utf8_lossy(data);
        println!("  - {} at ({:.4}, {:.4})", city_info, point.x(), point.y());
    }

    // ========================================
    // 4. Bounding Box Operations
    // ========================================
    println!("\n4. Bounding Box Operations");
    println!("{}", "=".repeat(50));

    // Create a bounding box around the New York area
    let ny_bbox = bounding_box(-74.5, 40.5, -73.5, 41.0)?;
    println!("NY Area Bounding Box: {:?}", ny_bbox);

    // Find cities in bounding box
    let cities_in_bbox = db.find_within_bounds("world_cities", 40.5, -74.5, 41.0, -73.5, 100)?;
    println!("\nCities in NY area bounding box:");
    for (_point, data) in &cities_in_bbox {
        let city_info = String::from_utf8_lossy(data);
        println!("  - {}", city_info);
    }

    // ========================================
    // 5. Convex Hull
    // ========================================
    println!("\n5. Convex Hull Calculation");
    println!("{}", "=".repeat(50));

    // Get all city points
    let city_points: Vec<Point> = cities.iter().map(|(p, _, _)| *p).collect();

    // Calculate convex hull
    if let Some(hull) = convex_hull(&city_points) {
        println!("Convex hull of all cities:");
        println!("  Exterior points: {}", hull.exterior().0.len() - 1);
        for coord in hull.exterior().0.iter().take(5) {
            println!("    ({:.4}, {:.4})", coord.x, coord.y);
        }
    }

    // ========================================
    // 6. Bounding Rectangle
    // ========================================
    println!("\n6. Bounding Rectangle");
    println!("{}", "=".repeat(50));

    if let Some(bbox) = bounding_rect_for_points(&city_points) {
        println!("Bounding rectangle of all cities:");
        println!("  Min: ({:.4}, {:.4})", bbox.min().x, bbox.min().y);
        println!("  Max: ({:.4}, {:.4})", bbox.max().x, bbox.max().y);
        println!("  Width:  {:.2}°", bbox.max().x - bbox.min().x);
        println!("  Height: {:.2}°", bbox.max().y - bbox.min().y);
    }

    // ========================================
    // 7. Advanced Radius Queries
    // ========================================
    println!("\n7. Advanced Radius Queries");
    println!("{}", "=".repeat(50));

    // Count cities within 1000km of NYC
    let count = db.count_within_radius("world_cities", &new_york, 1_000_000.0)?;
    println!("Cities within 1000km of NYC: {}", count);

    // Check if any cities exist within 100km
    let has_nearby = db.intersects_radius("world_cities", &new_york, 100_000.0)?;
    println!("Has cities within 100km of NYC: {}", has_nearby);

    // Query with radius
    let nearby = db.query_within_radius("world_cities", &new_york, 200_000.0, 10)?;
    println!("\nCities within 200km of NYC:");
    for (point, data, _distance) in &nearby {
        let city_info = String::from_utf8_lossy(data);
        let dist = distance_between(&new_york, point, DistanceMetric::Haversine);
        println!("  - {} ({:.2} km)", city_info, dist / 1000.0);
    }

    // ========================================
    // 8. Spatial Analytics
    // ========================================
    println!("\n8. Spatial Analytics");
    println!("{}", "=".repeat(50));

    // Find the two most distant cities (brute force)
    let mut max_distance = 0.0;
    let mut furthest_pair = ("", "");

    for (i, (p1, n1, _)) in cities.iter().enumerate() {
        for (p2, n2, _) in cities.iter().skip(i + 1) {
            let dist = distance_between(p1, p2, DistanceMetric::Geodesic);
            if dist > max_distance {
                max_distance = dist;
                furthest_pair = (n1, n2);
            }
        }
    }

    println!(
        "Most distant city pair: {} ↔ {}",
        furthest_pair.0, furthest_pair.1
    );
    println!("Distance: {:.2} km", max_distance / 1000.0);

    // Calculate average distance between all US cities
    let us_cities: Vec<_> = cities
        .iter()
        .filter(|(_, _, country)| *country == "USA")
        .collect();

    if us_cities.len() > 1 {
        let mut total_distance = 0.0;
        let mut count = 0;

        for (i, (p1, _, _)) in us_cities.iter().enumerate() {
            for (p2, _, _) in us_cities.iter().skip(i + 1) {
                total_distance += distance_between(p1, p2, DistanceMetric::Haversine);
                count += 1;
            }
        }

        let avg_distance = total_distance / count as f64;
        println!(
            "\nAverage distance between US cities: {:.2} km",
            avg_distance / 1000.0
        );
    }

    // ========================================
    // Summary
    // ========================================
    println!("\n{}", "=".repeat(50));
    println!("Summary:");
    println!("  - Demonstrated multiple distance metrics");
    println!("  - Performed K-nearest-neighbor searches");
    println!("  - Queried points within polygons");
    println!("  - Used bounding box operations");
    println!("  - Calculated convex hulls");
    println!("  - Performed spatial analytics");
    println!("\nAll spatial operations leverage the geo crate!");

    Ok(())
}

examples/bbox_database.rs (line 52)

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Spatio - Bounding Box Database ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // ========================================
    // 1. Store Geographic Regions
    // ========================================
    println!("1. Storing Geographic Regions");
    println!("------------------------------");

    // Define NYC boroughs as bounding boxes
    let manhattan = BoundingBox2D::new(-74.0479, 40.6829, -73.9067, 40.8820);
    let brooklyn = BoundingBox2D::new(-74.0421, 40.5707, -73.8333, 40.7395);
    let queens = BoundingBox2D::new(-73.9626, 40.5431, -73.7004, 40.8007);
    let bronx = BoundingBox2D::new(-73.9338, 40.7855, -73.7654, 40.9176);
    let staten_island = BoundingBox2D::new(-74.2558, 40.4960, -74.0526, 40.6490);

    // Store regions in database
    db.insert_bbox("region:manhattan", &manhattan, None)?;
    db.insert_bbox("region:brooklyn", &brooklyn, None)?;
    db.insert_bbox("region:queens", &queens, None)?;
    db.insert_bbox("region:bronx", &bronx, None)?;
    db.insert_bbox("region:staten_island", &staten_island, None)?;

    println!("   ✓ Stored 5 NYC borough boundaries");

    // ========================================
    // 2. Retrieve Stored Regions
    // ========================================
    println!("\n2. Retrieving Stored Regions");
    println!("-----------------------------");

    if let Some(retrieved_manhattan) = db.get_bbox("region:manhattan")? {
        println!("   Manhattan:");
        println!(
            "     Area: {:.4}° × {:.4}°",
            retrieved_manhattan.width(),
            retrieved_manhattan.height()
        );
        println!(
            "     Center: ({:.4}, {:.4})",
            retrieved_manhattan.center().x(),
            retrieved_manhattan.center().y()
        );
    }

    // ========================================
    // 3. Store POIs and Query by Region
    // ========================================
    println!("\n3. Store POIs and Query by Region");
    println!("-----------------------------------");

    // Store points of interest
    db.insert_point("poi", &Point::new(-73.9855, 40.7580), b"times_square", None)?;
    db.insert_point("poi", &Point::new(-73.9665, 40.7829), b"central_park", None)?;
    db.insert_point("poi", &Point::new(-73.9857, 40.7484), b"empire_state", None)?;
    db.insert_point(
        "poi",
        &Point::new(-73.9969, 40.7061),
        b"brooklyn_bridge",
        None,
    )?;
    db.insert_point(
        "poi",
        &Point::new(-73.9690, 40.6602),
        b"prospect_park",
        None,
    )?;
    db.insert_point("poi", &Point::new(-73.9799, 40.5755), b"coney_island", None)?;

    println!("   ✓ Stored 6 points of interest");

    // Query POIs in Manhattan
    let manhattan_pois = db.query_within_bbox("poi", &manhattan, 100)?;
    println!("\n   POIs in Manhattan: {}", manhattan_pois.len());
    for (point, data) in &manhattan_pois {
        let name = String::from_utf8_lossy(data);
        println!("     - {} at ({:.4}, {:.4})", name, point.x(), point.y());
    }

    // Query POIs in Brooklyn
    let brooklyn_pois = db.query_within_bbox("poi", &brooklyn, 100)?;
    println!("\n   POIs in Brooklyn: {}", brooklyn_pois.len());

    // ========================================
    // 4. Find Intersecting Regions
    // ========================================
    println!("\n4. Finding Intersecting Regions");
    println!("--------------------------------");

    // Create a search area (covering parts of Manhattan and Queens)
    let search_area = BoundingBox2D::new(-73.98, 40.72, -73.92, 40.78);

    let intersecting = db.find_intersecting_bboxes("region:", &search_area)?;
    println!(
        "   Search area intersects with {} boroughs:",
        intersecting.len()
    );
    for (key, _bbox) in &intersecting {
        println!("     - {}", key.replace("region:", ""));
    }

    // ========================================
    // 5. Delivery Zone Management
    // ========================================
    println!("\n5. Delivery Zone Management");
    println!("----------------------------");

    // Define delivery zones
    let zone_a = BoundingBox2D::new(-74.02, 40.70, -73.98, 40.74);
    let zone_b = BoundingBox2D::new(-74.00, 40.72, -73.96, 40.76);
    let zone_c = BoundingBox2D::new(-73.98, 40.74, -73.94, 40.78);

    db.insert_bbox("delivery:zone_a", &zone_a, None)?;
    db.insert_bbox("delivery:zone_b", &zone_b, None)?;
    db.insert_bbox("delivery:zone_c", &zone_c, None)?;

    println!("   ✓ Created 3 delivery zones");

    // Check which zones overlap
    let overlapping_with_a = db.find_intersecting_bboxes("delivery:", &zone_a)?;
    println!(
        "\n   Zone A overlaps with {} zones (including itself)",
        overlapping_with_a.len()
    );

    // ========================================
    // 6. Service Area Lookup
    // ========================================
    println!("\n6. Service Area Lookup");
    println!("-----------------------");

    // Check if various locations are in service areas
    let locations = vec![
        ("Customer 1", Point::new(-74.00, 40.72)),
        ("Customer 2", Point::new(-73.97, 40.75)),
        ("Customer 3", Point::new(-74.05, 40.68)),
    ];

    for (name, location) in &locations {
        let mut in_zone = false;
        for (zone_key, zone_bbox) in &overlapping_with_a {
            if zone_bbox.contains_point(location) {
                println!(
                    "   {} at ({:.4}, {:.4}) is in {}",
                    name,
                    location.x(),
                    location.y(),
                    zone_key.replace("delivery:", "")
                );
                in_zone = true;
                break;
            }
        }
        if !in_zone {
            println!(
                "   {} at ({:.4}, {:.4}) is outside all zones",
                name,
                location.x(),
                location.y()
            );
        }
    }

    // ========================================
    // 7. Geofencing Example
    // ========================================
    println!("\n7. Geofencing Example");
    println!("----------------------");

    // Define restricted areas
    let airport_zone = BoundingBox2D::new(-73.82, 40.63, -73.76, 40.66);
    db.insert_bbox("restricted:jfk_airport", &airport_zone, None)?;

    let military_zone = BoundingBox2D::new(-74.08, 40.60, -74.03, 40.64);
    db.insert_bbox("restricted:military", &military_zone, None)?;

    println!("   ✓ Defined 2 restricted zones");

    // Check if drone locations are in restricted areas
    let drone_locations = vec![
        ("Drone 1", Point::new(-73.79, 40.64)),
        ("Drone 2", Point::new(-74.00, 40.70)),
    ];

    for (drone, location) in &drone_locations {
        let restricted = db.find_intersecting_bboxes(
            "restricted:",
            &BoundingBox2D::new(
                location.x() - 0.001,
                location.y() - 0.001,
                location.x() + 0.001,
                location.y() + 0.001,
            ),
        )?;

        if !restricted.is_empty() {
            println!(
                "   ⚠ {} at ({:.4}, {:.4}) is in restricted area: {}",
                drone,
                location.x(),
                location.y(),
                restricted[0].0.replace("restricted:", "")
            );
        } else {
            println!(
                "   ✓ {} at ({:.4}, {:.4}) is in safe area",
                drone,
                location.x(),
                location.y()
            );
        }
    }

    // ========================================
    // 8. Spatial Analytics
    // ========================================
    println!("\n8. Spatial Analytics");
    println!("---------------------");

    // Calculate coverage area
    let mut total_width = 0.0;
    let mut total_height = 0.0;
    let mut count = 0;

    let all_regions = vec![
        ("Manhattan", &manhattan),
        ("Brooklyn", &brooklyn),
        ("Queens", &queens),
        ("Bronx", &bronx),
        ("Staten Island", &staten_island),
    ];

    for (name, bbox) in &all_regions {
        total_width += bbox.width();
        total_height += bbox.height();
        count += 1;
        println!(
            "   {} coverage: {:.4}° × {:.4}°",
            name,
            bbox.width(),
            bbox.height()
        );
    }

    let avg_width = total_width / count as f64;
    let avg_height = total_height / count as f64;

    println!(
        "\n   Average borough size: {:.4}° × {:.4}°",
        avg_width, avg_height
    );

    // ========================================
    // 9. Database Statistics
    // ========================================
    println!("\n9. Database Statistics");
    println!("-----------------------");

    let stats = db.stats();
    println!("   Total keys: {}", stats.key_count);
    println!("   Total operations: {}", stats.operations_count);

    // Count different types of data
    let poi_count = manhattan_pois.len() + brooklyn_pois.len();
    println!("   Stored POIs: {}", poi_count);
    println!("   Stored regions: 5");
    println!("   Delivery zones: 3");
    println!("   Restricted zones: 2");

    println!("\n=== Bounding Box Database Integration Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Store and retrieve bounding boxes");
    println!("  • Query POIs within regions");
    println!("  • Find intersecting regions");
    println!("  • Delivery zone management");
    println!("  • Service area lookups");
    println!("  • Geofencing and restricted areas");
    println!("  • Spatial analytics");

    Ok(())
}

examples/bounding_boxes.rs (line 42)

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Spatio - Bounding Box Examples ===\n");

    // Create an in-memory database
    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // ========================================
    // 1. Basic 2D Bounding Box Operations
    // ========================================
    println!("1. Basic 2D Bounding Box");
    println!("-------------------------");

    // Create a bounding box for Manhattan
    let manhattan = BoundingBox2D::new(
        -74.0479, 40.6829, // Southwest corner (Battery Park)
        -73.9067, 40.8820, // Northeast corner (Inwood)
    );

    println!("   Manhattan bounding box:");
    println!(
        "     Min: ({:.4}, {:.4})",
        manhattan.min_x(),
        manhattan.min_y()
    );
    println!(
        "     Max: ({:.4}, {:.4})",
        manhattan.max_x(),
        manhattan.max_y()
    );
    println!(
        "     Center: ({:.4}, {:.4})",
        manhattan.center().x(),
        manhattan.center().y()
    );
    println!(
        "     Width: {:.4}°, Height: {:.4}°",
        manhattan.width(),
        manhattan.height()
    );

    // Check if points are within Manhattan
    let times_square = Point::new(-73.9855, 40.7580);
    let brooklyn_bridge = Point::new(-73.9969, 40.7061);
    let statue_of_liberty = Point::new(-74.0445, 40.6892);
    let jfk_airport = Point::new(-73.7781, 40.6413);

    println!("\n   Point containment checks:");
    println!(
        "     Times Square: {}",
        manhattan.contains_point(&times_square)
    );
    println!(
        "     Brooklyn Bridge: {}",
        manhattan.contains_point(&brooklyn_bridge)
    );
    println!(
        "     Statue of Liberty: {}",
        manhattan.contains_point(&statue_of_liberty)
    );
    println!(
        "     JFK Airport: {}",
        manhattan.contains_point(&jfk_airport)
    );

    // ========================================
    // 2. Bounding Box Intersection
    // ========================================
    println!("\n2. Bounding Box Intersection");
    println!("-----------------------------");

    // Create bounding boxes for different NYC boroughs
    let manhattan_bbox = BoundingBox2D::new(-74.0479, 40.6829, -73.9067, 40.8820);
    let brooklyn_bbox = BoundingBox2D::new(-74.0421, 40.5707, -73.8333, 40.7395);
    let queens_bbox = BoundingBox2D::new(-73.9626, 40.5431, -73.7004, 40.8007);

    println!(
        "   Manhattan ∩ Brooklyn: {}",
        manhattan_bbox.intersects(&brooklyn_bbox)
    );
    println!(
        "   Manhattan ∩ Queens: {}",
        manhattan_bbox.intersects(&queens_bbox)
    );
    println!(
        "   Brooklyn ∩ Queens: {}",
        brooklyn_bbox.intersects(&queens_bbox)
    );

    // ========================================
    // 3. Expanding Bounding Boxes
    // ========================================
    println!("\n3. Expanding Bounding Boxes");
    println!("----------------------------");

    let central_park = BoundingBox2D::new(-73.9812, 40.7644, -73.9492, 40.8003);
    println!("   Central Park original:");
    println!(
        "     Width: {:.4}°, Height: {:.4}°",
        central_park.width(),
        central_park.height()
    );

    // Expand by 0.01 degrees (~1 km)
    let expanded = central_park.expand(0.01);
    println!("\n   Expanded by 0.01°:");
    println!(
        "     Width: {:.4}°, Height: {:.4}°",
        expanded.width(),
        expanded.height()
    );
    println!(
        "     Growth: {:.4}° in each direction",
        (expanded.width() - central_park.width()) / 2.0
    );

    // ========================================
    // 4. 3D Bounding Boxes
    // ========================================
    println!("\n4. 3D Bounding Boxes");
    println!("--------------------");

    // Create a 3D bounding box for a tall building's footprint with height
    let one_world_trade = BoundingBox3D::new(
        -74.0134, 40.7127, 0.0, // Ground level southwest
        -74.0118, 40.7143, 541.0, // Top level northeast (541m height)
    );

    println!("   One World Trade Center:");
    println!(
        "     Footprint: {:.4}° × {:.4}°",
        one_world_trade.width(),
        one_world_trade.height()
    );
    println!("     Height: {:.1} meters", one_world_trade.depth());
    println!(
        "     Volume: {:.6} cubic degrees×meters",
        one_world_trade.volume()
    );

    let (cx, cy, cz) = one_world_trade.center();
    println!("     Center: ({:.4}, {:.4}, {:.1}m)", cx, cy, cz);

    // Check if points at different altitudes are within the building
    println!("\n   Altitude containment checks:");
    println!(
        "     Ground level (0m): {}",
        one_world_trade.contains_point(-74.0126, 40.7135, 0.0)
    );
    println!(
        "     Mid-level (270m): {}",
        one_world_trade.contains_point(-74.0126, 40.7135, 270.0)
    );
    println!(
        "     Top (540m): {}",
        one_world_trade.contains_point(-74.0126, 40.7135, 540.0)
    );
    println!(
        "     Above (600m): {}",
        one_world_trade.contains_point(-74.0126, 40.7135, 600.0)
    );

    // ========================================
    // 5. 3D to 2D Projection
    // ========================================
    println!("\n5. 3D to 2D Projection");
    println!("----------------------");

    let building_3d = BoundingBox3D::new(-74.0, 40.7, 0.0, -73.9, 40.8, 200.0);
    let building_2d = building_3d.to_2d();

    println!("   3D Bounding Box:");
    println!(
        "     Dimensions: {:.4}° × {:.4}° × {:.1}m",
        building_3d.width(),
        building_3d.height(),
        building_3d.depth()
    );

    println!("\n   Projected to 2D:");
    println!(
        "     Dimensions: {:.4}° × {:.4}°",
        building_2d.width(),
        building_2d.height()
    );

    // ========================================
    // 6. Temporal Bounding Boxes
    // ========================================
    println!("\n6. Temporal Bounding Boxes");
    println!("--------------------------");

    // Track how a delivery zone changes over time
    let morning_zone = BoundingBox2D::new(-74.01, 40.71, -73.99, 40.73);
    let afternoon_zone = BoundingBox2D::new(-74.02, 40.70, -73.98, 40.74);

    let morning_time = SystemTime::now();
    let afternoon_time = SystemTime::now();

    let temporal_morning = TemporalBoundingBox2D::new(morning_zone.clone(), morning_time);
    let temporal_afternoon = TemporalBoundingBox2D::new(afternoon_zone.clone(), afternoon_time);

    println!("   Morning delivery zone:");
    println!(
        "     Area: {:.4}° × {:.4}°",
        temporal_morning.bbox().width(),
        temporal_morning.bbox().height()
    );

    println!("\n   Afternoon delivery zone:");
    println!(
        "     Area: {:.4}° × {:.4}°",
        temporal_afternoon.bbox().width(),
        temporal_afternoon.bbox().height()
    );

    println!(
        "     Expansion: {:.4}° wider, {:.4}° taller",
        afternoon_zone.width() - morning_zone.width(),
        afternoon_zone.height() - morning_zone.height()
    );

    // ========================================
    // 7. Storing Bounding Boxes in Database
    // ========================================
    println!("\n7. Storing Bounding Boxes");
    println!("-------------------------");

    // Serialize and store bounding boxes
    let bbox_json = serde_json::to_vec(&manhattan)?;
    db.insert("zones:manhattan", bbox_json, None)?;

    let bbox3d_json = serde_json::to_vec(&one_world_trade)?;
    db.insert("buildings:wtc", bbox3d_json, None)?;

    println!("   ✓ Stored Manhattan bounding box");
    println!("   ✓ Stored One World Trade Center 3D box");

    // Retrieve and deserialize
    if let Some(data) = db.get("zones:manhattan")? {
        let retrieved: BoundingBox2D = serde_json::from_slice(&data)?;
        println!("\n   Retrieved Manhattan box:");
        println!(
            "     Center: ({:.4}, {:.4})",
            retrieved.center().x(),
            retrieved.center().y()
        );
    }

    // ========================================
    // 8. Practical Use Cases
    // ========================================
    println!("\n8. Practical Use Cases");
    println!("----------------------");

    // Geofencing
    let delivery_area = BoundingBox2D::new(-74.02, 40.70, -73.98, 40.75);
    let current_location = Point::new(-74.00, 40.72);

    if delivery_area.contains_point(&current_location) {
        println!("   ✓ Delivery driver is within service area");
    } else {
        println!("   ✗ Delivery driver is outside service area");
    }

    // Airspace management
    let airspace = BoundingBox3D::new(
        -74.1, 40.6, 0.0, // Ground level
        -73.8, 40.9, 3000.0, // 3000m ceiling
    );
    let drone_altitude = 150.0; // meters
    let drone_location = (-74.0, 40.75, drone_altitude);

    if airspace.contains_point(drone_location.0, drone_location.1, drone_location.2) {
        println!("   ✓ Drone is within authorized airspace");
    }

    // Region overlap detection
    let zone_a = BoundingBox2D::new(-74.05, 40.70, -74.00, 40.75);
    let zone_b = BoundingBox2D::new(-74.02, 40.72, -73.97, 40.77);

    if zone_a.intersects(&zone_b) {
        println!("   ⚠ Service zones A and B overlap - coordination needed");
    }

    println!("\n=== Bounding Box Examples Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Create and manipulate 2D/3D bounding boxes");
    println!("  • Check point containment");
    println!("  • Detect box intersections");
    println!("  • Expand regions");
    println!("  • Project 3D to 2D");
    println!("  • Track temporal changes");
    println!("  • Serialize and store in database");
    println!("  • Geofencing and airspace management");

    Ok(())
}

pub fn y(&self) -> f64

Get the y coordinate (latitude).

Examples found in repository

examples/spatial_queries.rs (line 99)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Spatio - Spatial Queries ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // === SETUP: Insert World Cities ===
    println!("Setting up test data...");

    let cities = vec![
        ("New York", Point::new(-74.0060, 40.7128)),
        ("London", Point::new(-0.1278, 51.5074)),
        ("Paris", Point::new(2.3522, 48.8566)),
        ("Berlin", Point::new(13.4050, 52.5200)),
        ("Madrid", Point::new(-3.7038, 40.4168)),
        ("Rome", Point::new(12.4964, 41.9028)),
        ("Tokyo", Point::new(139.6503, 35.6762)),
        ("Sydney", Point::new(151.2093, -33.8688)),
        ("Mumbai", Point::new(72.8777, 19.0760)),
        ("Cairo", Point::new(31.2357, 30.0444)),
        ("São Paulo", Point::new(-46.6333, -23.5505)),
        ("Mexico City", Point::new(-99.1332, 19.4326)),
    ];

    for (name, point) in &cities {
        db.insert_point("world_cities", point, name.as_bytes(), None)?;
    }
    println!("   Added {} cities to spatial index\n", cities.len());

    // === 1. RADIUS QUERIES ===
    println!("1. Radius-Based Queries (query_within_radius)");
    println!("----------------------------------------------");

    let london = Point::new(-0.1278, 51.5074);

    // Find cities within 500km of London
    let nearby_500km = db.query_within_radius("world_cities", &london, 500_000.0, 10)?;
    println!("   Cities within 500km of London: {}", nearby_500km.len());
    for (_, data, _) in &nearby_500km {
        println!("     - {}", String::from_utf8_lossy(data));
    }

    // Find cities within 2000km of London
    let nearby_2000km = db.query_within_radius("world_cities", &london, 2_000_000.0, 10)?;
    println!(
        "\n   Cities within 2000km of London: {}",
        nearby_2000km.len()
    );
    for (_, data, _) in &nearby_2000km {
        println!("     - {}", String::from_utf8_lossy(data));
    }

    // Use limit to get only closest N cities
    let closest_3 = db.query_within_radius("world_cities", &london, f64::INFINITY, 3)?;
    println!("\n   Closest 3 cities to London:");
    for (i, (_, data, _)) in closest_3.iter().enumerate() {
        println!("     {}. {}", i + 1, String::from_utf8_lossy(data));
    }
    println!();

    // === 2. EXISTENCE CHECKS ===
    println!("2. Existence Checks (contains_point)");
    println!("-------------------------------------");

    let has_nearby_500km = db.intersects_radius("world_cities", &london, 500_000.0)?;
    let has_nearby_100km = db.intersects_radius("world_cities", &london, 100_000.0)?;

    println!("   Any cities within 500km of London? {}", has_nearby_500km);
    println!("   Any cities within 100km of London? {}", has_nearby_100km);

    // === 3. COUNTING POINTS ===
    println!("3. Counting Points (count_within_radius)");
    println!("----------------------------------------");

    let count_500km = db.count_within_radius("world_cities", &london, 500_000.0)?;
    let count_1000km = db.count_within_radius("world_cities", &london, 1_000_000.0)?;
    let count_2000km = db.count_within_radius("world_cities", &london, 2_000_000.0)?;

    println!("   Cities within 500km of London: {}", count_500km);
    println!("   Cities within 1000km of London: {}", count_1000km);
    println!("   Cities within 2000km of London: {}", count_2000km);
    println!();

    // === 4. BOUNDING BOX QUERIES ===
    println!("4. Bounding Box Queries");
    println!("-----------------------");

    // European bounding box (min_lon, min_lat, max_lon, max_lat)
    println!("   European region (lon: -10 to 20, lat: 40 to 60):");
    let europe_cities = db.find_within_bounds("world_cities", -10.0, 40.0, 20.0, 60.0, 20)?;
    println!("     Found {} cities:", europe_cities.len());
    for (point, data) in &europe_cities {
        println!(
            "       - {} at ({:.2}°, {:.2}°)",
            String::from_utf8_lossy(data),
            point.x(),
            point.y()
        );
    }

    // Asia-Pacific region
    println!("\n   Asia-Pacific region (lon: 70 to 180, lat: -40 to 40):");
    let asia_cities = db.find_within_bounds("world_cities", 70.0, -40.0, 180.0, 40.0, 20)?;
    println!("     Found {} cities:", asia_cities.len());
    for (_, data) in &asia_cities {
        println!("       - {}", String::from_utf8_lossy(data));
    }

    // Americas region
    println!("\n   Americas region (lon: -130 to -30, lat: -60 to 60):");
    let americas_cities = db.find_within_bounds("world_cities", -130.0, -60.0, -30.0, 60.0, 20)?;
    println!("     Found {} cities:", americas_cities.len());
    for (_, data) in &americas_cities {
        println!("       - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === 5. BOUNDING BOX INTERSECTION ===
    println!("5. Bounding Box Intersection (intersects_bounds)");
    println!("------------------------------------------------");

    let has_european = db.intersects_bounds("world_cities", -10.0, 40.0, 20.0, 60.0)?;
    let has_antarctica = db.intersects_bounds("world_cities", -180.0, -90.0, 180.0, -60.0)?;

    println!("   European region has cities? {}", has_european);
    println!("   Antarctica region has cities? {}", has_antarctica);
    println!();

    // === 6. MULTIPLE NAMESPACES ===
    println!("6. Multiple Namespaces");
    println!("----------------------");

    // Add some landmarks in London
    let london_landmarks = vec![
        ("Big Ben", Point::new(-0.1245, 51.4994)),
        ("Tower Bridge", Point::new(-0.0754, 51.5055)),
        ("London Eye", Point::new(-0.1195, 51.5033)),
        ("Buckingham Palace", Point::new(-0.1419, 51.5014)),
    ];

    for (name, point) in &london_landmarks {
        db.insert_point("landmarks", point, name.as_bytes(), None)?;
    }

    println!("   Added {} London landmarks", london_landmarks.len());

    // Query different namespaces from same location
    let center_london = Point::new(-0.1278, 51.5074);

    let nearby_cities = db.query_within_radius("world_cities", &center_london, 10_000.0, 10)?;
    let nearby_landmarks = db.query_within_radius("landmarks", &center_london, 10_000.0, 10)?;

    println!("   Within 10km of center London:");
    println!("     Cities: {}", nearby_cities.len());
    println!("     Landmarks: {}", nearby_landmarks.len());

    println!("\n   Landmarks within 2km:");
    let close_landmarks = db.query_within_radius("landmarks", &center_london, 2_000.0, 10)?;
    for (_, data, _) in &close_landmarks {
        println!("     - {}", String::from_utf8_lossy(data));
    }
    println!();

    // === 7. QUERY LIMITS ===
    println!("7. Query Result Limiting");
    println!("------------------------");

    let all_cities = db.query_within_radius("world_cities", &london, f64::INFINITY, 100)?;
    let top_5 = db.query_within_radius("world_cities", &london, f64::INFINITY, 5)?;
    let top_3 = db.query_within_radius("world_cities", &london, f64::INFINITY, 3)?;

    println!("   Total cities in database: {}", all_cities.len());
    println!("   With limit=5: {} cities", top_5.len());
    println!("   With limit=3: {} cities", top_3.len());
    println!();

    // === SUMMARY ===
    let stats = db.stats();
    println!("=== Query Summary ===");
    println!("Database statistics:");
    println!("  Total keys: {}", stats.key_count);
    println!("  Operations: {}", stats.operations_count);

    println!("\nSpatial query methods demonstrated:");
    println!("  • query_within_radius - Find points within distance");
    println!("  • contains_point - Check if points exist in radius");
    println!("  • count_within_radius - Count points efficiently");
    println!("  • find_within_bounds - Rectangular region queries");
    println!("  • intersects_bounds - Check bounding box intersection");
    println!("  • Multiple namespaces - Organize different point types");
    println!("  • Result limiting - Control query result size");

    Ok(())
}

examples/trajectory_tracking.rs (line 51)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Spatio - Trajectory Tracking ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // === 1. BASIC TRAJECTORY STORAGE ===
    println!("1. Basic Trajectory Storage");
    println!("---------------------------");

    // Create a simple delivery route
    let delivery_route = vec![
        TemporalPoint {
            point: Point::new(-74.0060, 40.7128), // NYC
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-74.0040, 40.7150),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260), // +1 min
        },
        TemporalPoint {
            point: Point::new(-74.0020, 40.7172),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320), // +2 min
        },
        TemporalPoint {
            point: Point::new(-74.0000, 40.7194),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995380), // +3 min
        },
    ];

    db.insert_trajectory("vehicle:truck001", &delivery_route, None)?;
    println!(
        "   Stored delivery truck trajectory with {} waypoints\n",
        delivery_route.len()
    );

    // === 2. QUERY FULL TRAJECTORY ===
    println!("2. Query Full Trajectory");
    println!("------------------------");

    let full_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995400)?;
    println!("   Retrieved {} waypoints:", full_path.len());
    for (i, tp) in full_path.iter().enumerate() {
        println!(
            "     {}. Point ({:.4}°, {:.4}°) at timestamp {}",
            i + 1,
            tp.point.x(),
            tp.point.y(),
            tp.timestamp.duration_since(UNIX_EPOCH).unwrap().as_secs()
        );
    }
    println!();

    // === 3. QUERY TIME RANGE ===
    println!("3. Query Specific Time Range");
    println!("----------------------------");

    // Get only first 2 minutes of trajectory
    let partial_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995320)?;
    println!("   First 2 minutes: {} waypoints", partial_path.len());

    // Get only middle segment
    let middle_segment = db.query_trajectory("vehicle:truck001", 1640995260, 1640995320)?;
    println!("   Middle segment: {} waypoints\n", middle_segment.len());

    // === 4. MULTIPLE TRAJECTORIES ===
    println!("4. Multiple Trajectories");
    println!("------------------------");

    // Add taxi route
    let taxi_route = vec![
        TemporalPoint {
            point: Point::new(-0.1278, 51.5074), // London
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-0.1195, 51.5033),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260),
        },
        TemporalPoint {
            point: Point::new(-0.1245, 51.4994),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320),
        },
    ];

    db.insert_trajectory("vehicle:taxi042", &taxi_route, None)?;
    println!(
        "   Stored taxi trajectory with {} waypoints",
        taxi_route.len()
    );

    // Add bus route
    let bus_route = vec![
        TemporalPoint {
            point: Point::new(2.3522, 48.8566), // Paris
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(2.3550, 48.8580),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995300),
        },
        TemporalPoint {
            point: Point::new(2.3580, 48.8600),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995400),
        },
        TemporalPoint {
            point: Point::new(2.3610, 48.8620),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995500),
        },
        TemporalPoint {
            point: Point::new(2.3640, 48.8640),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995600),
        },
    ];

    db.insert_trajectory("vehicle:bus123", &bus_route, None)?;
    println!(
        "   Stored bus trajectory with {} waypoints\n",
        bus_route.len()
    );

    // === 5. QUERY DIFFERENT VEHICLES ===
    println!("5. Query Different Vehicles");
    println!("---------------------------");

    let truck_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995400)?;
    let taxi_path = db.query_trajectory("vehicle:taxi042", 1640995200, 1640995400)?;
    let bus_path = db.query_trajectory("vehicle:bus123", 1640995200, 1640995700)?;

    println!("   Truck waypoints: {}", truck_path.len());
    println!("   Taxi waypoints: {}", taxi_path.len());
    println!("   Bus waypoints: {}\n", bus_path.len());

    // === 6. LONG-RUNNING TRAJECTORY ===
    println!("6. Long-Running Trajectory (High Frequency)");
    println!("-------------------------------------------");

    // Simulate a drone with frequent position updates
    let mut drone_path = Vec::new();
    let start_time = 1641000000;

    for i in 0..60 {
        // 60 waypoints, 1 per second
        drone_path.push(TemporalPoint {
            point: Point::new(
                -122.4194 + (i as f64 * 0.0001), // San Francisco area
                37.7749 + (i as f64 * 0.0001),
            ),
            timestamp: UNIX_EPOCH + Duration::from_secs(start_time + i),
        });
    }

    db.insert_trajectory("drone:delivery001", &drone_path, None)?;
    println!(
        "   Stored drone trajectory with {} waypoints",
        drone_path.len()
    );

    // Query specific time window (10 seconds)
    let window = db.query_trajectory("drone:delivery001", start_time, start_time + 10)?;
    println!(
        "   Retrieved 10-second window: {} waypoints\n",
        window.len()
    );

    // === 7. TRAJECTORY UPDATES ===
    println!("7. Trajectory Updates");
    println!("---------------------");

    // Add more waypoints to existing trajectory
    let extended_route = vec![
        TemporalPoint {
            point: Point::new(-74.0060, 40.7128),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995200),
        },
        TemporalPoint {
            point: Point::new(-74.0040, 40.7150),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995260),
        },
        TemporalPoint {
            point: Point::new(-74.0020, 40.7172),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995320),
        },
        TemporalPoint {
            point: Point::new(-74.0000, 40.7194),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995380),
        },
        // New waypoints
        TemporalPoint {
            point: Point::new(-73.9980, 40.7216),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995440),
        },
        TemporalPoint {
            point: Point::new(-73.9960, 40.7238),
            timestamp: UNIX_EPOCH + Duration::from_secs(1640995500),
        },
    ];

    db.insert_trajectory("vehicle:truck001", &extended_route, None)?;
    let updated_path = db.query_trajectory("vehicle:truck001", 1640995200, 1640995600)?;
    println!(
        "   Extended truck trajectory from 4 to {} waypoints\n",
        updated_path.len()
    );

    // === 8. DATABASE STATISTICS ===
    println!("8. Database Statistics");
    println!("----------------------");

    let stats = db.stats();
    println!("   Total keys in database: {}", stats.key_count);
    println!("   Total operations: {}\n", stats.operations_count);

    // === 9. USE CASES ===
    println!("=== Common Use Cases ===\n");

    println!("Fleet Management:");
    println!("  • Track multiple vehicles in real-time");
    println!("  • Query historical routes for analysis");
    println!("  • Retrieve specific time windows for incidents\n");

    println!("Delivery Tracking:");
    println!("  • Store complete delivery routes");
    println!("  • Query progress during specific periods");
    println!("  • Analyze route efficiency\n");

    println!("Drone Operations:");
    println!("  • High-frequency position updates");
    println!("  • Flight path analysis");
    println!("  • Time-based route queries\n");

    println!("Asset Tracking:");
    println!("  • Monitor movement of valuable items");
    println!("  • Historical location queries");
    println!("  • Route verification\n");

    println!("=== Trajectory Tracking Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Store trajectories with timestamps");
    println!("  • Query full trajectories");
    println!("  • Query specific time ranges");
    println!("  • Track multiple vehicles/objects");
    println!("  • High-frequency updates");
    println!("  • Trajectory extensions/updates");

    Ok(())
}

examples/advanced_spatial.rs (line 111)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== Advanced Spatial Operations Demo ===\n");

    // Create an in-memory database
    let mut db = Spatio::memory()?;

    // ========================================
    // 1. Distance Calculations
    // ========================================
    println!("1. Distance Calculations");
    println!("{}", "=".repeat(50));

    let new_york = Point::new(-74.0060, 40.7128);
    let los_angeles = Point::new(-118.2437, 34.0522);
    let london = Point::new(-0.1278, 51.5074);

    // Calculate distances using different metrics
    let dist_haversine = distance_between(&new_york, &los_angeles, DistanceMetric::Haversine);
    let dist_geodesic = distance_between(&new_york, &los_angeles, DistanceMetric::Geodesic);
    let dist_rhumb = distance_between(&new_york, &los_angeles, DistanceMetric::Rhumb);

    println!("NYC to LA:");
    println!("  Haversine:  {:.2} km", dist_haversine / 1000.0);
    println!("  Geodesic:   {:.2} km", dist_geodesic / 1000.0);
    println!("  Rhumb:      {:.2} km", dist_rhumb / 1000.0);

    // Using the database method
    let db_distance = db.distance_between(&new_york, &london, DistanceMetric::Haversine)?;
    println!("\nNYC to London: {:.2} km", db_distance / 1000.0);

    // ========================================
    // 2. K-Nearest-Neighbors (KNN)
    // ========================================
    println!("\n2. K-Nearest-Neighbors Query");
    println!("{}", "=".repeat(50));

    // Insert major cities
    let cities = vec![
        (Point::new(-74.0060, 40.7128), "New York", "USA"),
        (Point::new(-118.2437, 34.0522), "Los Angeles", "USA"),
        (Point::new(-87.6298, 41.8781), "Chicago", "USA"),
        (Point::new(-95.3698, 29.7604), "Houston", "USA"),
        (Point::new(-75.1652, 39.9526), "Philadelphia", "USA"),
        (Point::new(-122.4194, 37.7749), "San Francisco", "USA"),
        (Point::new(-0.1278, 51.5074), "London", "UK"),
        (Point::new(2.3522, 48.8566), "Paris", "France"),
        (Point::new(139.6917, 35.6895), "Tokyo", "Japan"),
    ];

    for (point, name, country) in &cities {
        let data = format!("{},{}", name, country);
        db.insert_point("world_cities", point, data.as_bytes(), None)?;
    }

    // Find 3 nearest cities to a query point (somewhere in New Jersey)
    let query_point = Point::new(-74.1719, 40.7357);
    let nearest = db.knn(
        "world_cities",
        &query_point,
        3,
        500_000.0, // Search within 500km
        DistanceMetric::Haversine,
    )?;

    println!("3 nearest cities to query point:");
    for (i, (_point, data, distance)) in nearest.iter().enumerate() {
        let city_info = String::from_utf8_lossy(data);
        println!(
            "  {}. {} ({:.2} km away)",
            i + 1,
            city_info,
            distance / 1000.0
        );
    }

    // ========================================
    // 3. Polygon Queries
    // ========================================
    println!("\n3. Polygon Queries");
    println!("{}", "=".repeat(50));

    // Define a polygon covering parts of the eastern US
    use geo::polygon;
    let east_coast_polygon = polygon![
        (x: -80.0, y: 35.0),  // South
        (x: -70.0, y: 35.0),  // Southeast
        (x: -70.0, y: 45.0),  // Northeast
        (x: -80.0, y: 45.0),  // Northwest
        (x: -80.0, y: 35.0),  // Close the polygon
    ];
    let east_coast_polygon: Polygon = east_coast_polygon.into();

    let cities_in_polygon = db.query_within_polygon("world_cities", &east_coast_polygon, 100)?;

    println!("Cities within East Coast polygon:");
    for (point, data) in &cities_in_polygon {
        let city_info = String::from_utf8_lossy(data);
        println!("  - {} at ({:.4}, {:.4})", city_info, point.x(), point.y());
    }

    // ========================================
    // 4. Bounding Box Operations
    // ========================================
    println!("\n4. Bounding Box Operations");
    println!("{}", "=".repeat(50));

    // Create a bounding box around the New York area
    let ny_bbox = bounding_box(-74.5, 40.5, -73.5, 41.0)?;
    println!("NY Area Bounding Box: {:?}", ny_bbox);

    // Find cities in bounding box
    let cities_in_bbox = db.find_within_bounds("world_cities", 40.5, -74.5, 41.0, -73.5, 100)?;
    println!("\nCities in NY area bounding box:");
    for (_point, data) in &cities_in_bbox {
        let city_info = String::from_utf8_lossy(data);
        println!("  - {}", city_info);
    }

    // ========================================
    // 5. Convex Hull
    // ========================================
    println!("\n5. Convex Hull Calculation");
    println!("{}", "=".repeat(50));

    // Get all city points
    let city_points: Vec<Point> = cities.iter().map(|(p, _, _)| *p).collect();

    // Calculate convex hull
    if let Some(hull) = convex_hull(&city_points) {
        println!("Convex hull of all cities:");
        println!("  Exterior points: {}", hull.exterior().0.len() - 1);
        for coord in hull.exterior().0.iter().take(5) {
            println!("    ({:.4}, {:.4})", coord.x, coord.y);
        }
    }

    // ========================================
    // 6. Bounding Rectangle
    // ========================================
    println!("\n6. Bounding Rectangle");
    println!("{}", "=".repeat(50));

    if let Some(bbox) = bounding_rect_for_points(&city_points) {
        println!("Bounding rectangle of all cities:");
        println!("  Min: ({:.4}, {:.4})", bbox.min().x, bbox.min().y);
        println!("  Max: ({:.4}, {:.4})", bbox.max().x, bbox.max().y);
        println!("  Width:  {:.2}°", bbox.max().x - bbox.min().x);
        println!("  Height: {:.2}°", bbox.max().y - bbox.min().y);
    }

    // ========================================
    // 7. Advanced Radius Queries
    // ========================================
    println!("\n7. Advanced Radius Queries");
    println!("{}", "=".repeat(50));

    // Count cities within 1000km of NYC
    let count = db.count_within_radius("world_cities", &new_york, 1_000_000.0)?;
    println!("Cities within 1000km of NYC: {}", count);

    // Check if any cities exist within 100km
    let has_nearby = db.intersects_radius("world_cities", &new_york, 100_000.0)?;
    println!("Has cities within 100km of NYC: {}", has_nearby);

    // Query with radius
    let nearby = db.query_within_radius("world_cities", &new_york, 200_000.0, 10)?;
    println!("\nCities within 200km of NYC:");
    for (point, data, _distance) in &nearby {
        let city_info = String::from_utf8_lossy(data);
        let dist = distance_between(&new_york, point, DistanceMetric::Haversine);
        println!("  - {} ({:.2} km)", city_info, dist / 1000.0);
    }

    // ========================================
    // 8. Spatial Analytics
    // ========================================
    println!("\n8. Spatial Analytics");
    println!("{}", "=".repeat(50));

    // Find the two most distant cities (brute force)
    let mut max_distance = 0.0;
    let mut furthest_pair = ("", "");

    for (i, (p1, n1, _)) in cities.iter().enumerate() {
        for (p2, n2, _) in cities.iter().skip(i + 1) {
            let dist = distance_between(p1, p2, DistanceMetric::Geodesic);
            if dist > max_distance {
                max_distance = dist;
                furthest_pair = (n1, n2);
            }
        }
    }

    println!(
        "Most distant city pair: {} ↔ {}",
        furthest_pair.0, furthest_pair.1
    );
    println!("Distance: {:.2} km", max_distance / 1000.0);

    // Calculate average distance between all US cities
    let us_cities: Vec<_> = cities
        .iter()
        .filter(|(_, _, country)| *country == "USA")
        .collect();

    if us_cities.len() > 1 {
        let mut total_distance = 0.0;
        let mut count = 0;

        for (i, (p1, _, _)) in us_cities.iter().enumerate() {
            for (p2, _, _) in us_cities.iter().skip(i + 1) {
                total_distance += distance_between(p1, p2, DistanceMetric::Haversine);
                count += 1;
            }
        }

        let avg_distance = total_distance / count as f64;
        println!(
            "\nAverage distance between US cities: {:.2} km",
            avg_distance / 1000.0
        );
    }

    // ========================================
    // Summary
    // ========================================
    println!("\n{}", "=".repeat(50));
    println!("Summary:");
    println!("  - Demonstrated multiple distance metrics");
    println!("  - Performed K-nearest-neighbor searches");
    println!("  - Queried points within polygons");
    println!("  - Used bounding box operations");
    println!("  - Calculated convex hulls");
    println!("  - Performed spatial analytics");
    println!("\nAll spatial operations leverage the geo crate!");

    Ok(())
}

examples/bbox_database.rs (line 53)

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Spatio - Bounding Box Database ===\n");

    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // ========================================
    // 1. Store Geographic Regions
    // ========================================
    println!("1. Storing Geographic Regions");
    println!("------------------------------");

    // Define NYC boroughs as bounding boxes
    let manhattan = BoundingBox2D::new(-74.0479, 40.6829, -73.9067, 40.8820);
    let brooklyn = BoundingBox2D::new(-74.0421, 40.5707, -73.8333, 40.7395);
    let queens = BoundingBox2D::new(-73.9626, 40.5431, -73.7004, 40.8007);
    let bronx = BoundingBox2D::new(-73.9338, 40.7855, -73.7654, 40.9176);
    let staten_island = BoundingBox2D::new(-74.2558, 40.4960, -74.0526, 40.6490);

    // Store regions in database
    db.insert_bbox("region:manhattan", &manhattan, None)?;
    db.insert_bbox("region:brooklyn", &brooklyn, None)?;
    db.insert_bbox("region:queens", &queens, None)?;
    db.insert_bbox("region:bronx", &bronx, None)?;
    db.insert_bbox("region:staten_island", &staten_island, None)?;

    println!("   ✓ Stored 5 NYC borough boundaries");

    // ========================================
    // 2. Retrieve Stored Regions
    // ========================================
    println!("\n2. Retrieving Stored Regions");
    println!("-----------------------------");

    if let Some(retrieved_manhattan) = db.get_bbox("region:manhattan")? {
        println!("   Manhattan:");
        println!(
            "     Area: {:.4}° × {:.4}°",
            retrieved_manhattan.width(),
            retrieved_manhattan.height()
        );
        println!(
            "     Center: ({:.4}, {:.4})",
            retrieved_manhattan.center().x(),
            retrieved_manhattan.center().y()
        );
    }

    // ========================================
    // 3. Store POIs and Query by Region
    // ========================================
    println!("\n3. Store POIs and Query by Region");
    println!("-----------------------------------");

    // Store points of interest
    db.insert_point("poi", &Point::new(-73.9855, 40.7580), b"times_square", None)?;
    db.insert_point("poi", &Point::new(-73.9665, 40.7829), b"central_park", None)?;
    db.insert_point("poi", &Point::new(-73.9857, 40.7484), b"empire_state", None)?;
    db.insert_point(
        "poi",
        &Point::new(-73.9969, 40.7061),
        b"brooklyn_bridge",
        None,
    )?;
    db.insert_point(
        "poi",
        &Point::new(-73.9690, 40.6602),
        b"prospect_park",
        None,
    )?;
    db.insert_point("poi", &Point::new(-73.9799, 40.5755), b"coney_island", None)?;

    println!("   ✓ Stored 6 points of interest");

    // Query POIs in Manhattan
    let manhattan_pois = db.query_within_bbox("poi", &manhattan, 100)?;
    println!("\n   POIs in Manhattan: {}", manhattan_pois.len());
    for (point, data) in &manhattan_pois {
        let name = String::from_utf8_lossy(data);
        println!("     - {} at ({:.4}, {:.4})", name, point.x(), point.y());
    }

    // Query POIs in Brooklyn
    let brooklyn_pois = db.query_within_bbox("poi", &brooklyn, 100)?;
    println!("\n   POIs in Brooklyn: {}", brooklyn_pois.len());

    // ========================================
    // 4. Find Intersecting Regions
    // ========================================
    println!("\n4. Finding Intersecting Regions");
    println!("--------------------------------");

    // Create a search area (covering parts of Manhattan and Queens)
    let search_area = BoundingBox2D::new(-73.98, 40.72, -73.92, 40.78);

    let intersecting = db.find_intersecting_bboxes("region:", &search_area)?;
    println!(
        "   Search area intersects with {} boroughs:",
        intersecting.len()
    );
    for (key, _bbox) in &intersecting {
        println!("     - {}", key.replace("region:", ""));
    }

    // ========================================
    // 5. Delivery Zone Management
    // ========================================
    println!("\n5. Delivery Zone Management");
    println!("----------------------------");

    // Define delivery zones
    let zone_a = BoundingBox2D::new(-74.02, 40.70, -73.98, 40.74);
    let zone_b = BoundingBox2D::new(-74.00, 40.72, -73.96, 40.76);
    let zone_c = BoundingBox2D::new(-73.98, 40.74, -73.94, 40.78);

    db.insert_bbox("delivery:zone_a", &zone_a, None)?;
    db.insert_bbox("delivery:zone_b", &zone_b, None)?;
    db.insert_bbox("delivery:zone_c", &zone_c, None)?;

    println!("   ✓ Created 3 delivery zones");

    // Check which zones overlap
    let overlapping_with_a = db.find_intersecting_bboxes("delivery:", &zone_a)?;
    println!(
        "\n   Zone A overlaps with {} zones (including itself)",
        overlapping_with_a.len()
    );

    // ========================================
    // 6. Service Area Lookup
    // ========================================
    println!("\n6. Service Area Lookup");
    println!("-----------------------");

    // Check if various locations are in service areas
    let locations = vec![
        ("Customer 1", Point::new(-74.00, 40.72)),
        ("Customer 2", Point::new(-73.97, 40.75)),
        ("Customer 3", Point::new(-74.05, 40.68)),
    ];

    for (name, location) in &locations {
        let mut in_zone = false;
        for (zone_key, zone_bbox) in &overlapping_with_a {
            if zone_bbox.contains_point(location) {
                println!(
                    "   {} at ({:.4}, {:.4}) is in {}",
                    name,
                    location.x(),
                    location.y(),
                    zone_key.replace("delivery:", "")
                );
                in_zone = true;
                break;
            }
        }
        if !in_zone {
            println!(
                "   {} at ({:.4}, {:.4}) is outside all zones",
                name,
                location.x(),
                location.y()
            );
        }
    }

    // ========================================
    // 7. Geofencing Example
    // ========================================
    println!("\n7. Geofencing Example");
    println!("----------------------");

    // Define restricted areas
    let airport_zone = BoundingBox2D::new(-73.82, 40.63, -73.76, 40.66);
    db.insert_bbox("restricted:jfk_airport", &airport_zone, None)?;

    let military_zone = BoundingBox2D::new(-74.08, 40.60, -74.03, 40.64);
    db.insert_bbox("restricted:military", &military_zone, None)?;

    println!("   ✓ Defined 2 restricted zones");

    // Check if drone locations are in restricted areas
    let drone_locations = vec![
        ("Drone 1", Point::new(-73.79, 40.64)),
        ("Drone 2", Point::new(-74.00, 40.70)),
    ];

    for (drone, location) in &drone_locations {
        let restricted = db.find_intersecting_bboxes(
            "restricted:",
            &BoundingBox2D::new(
                location.x() - 0.001,
                location.y() - 0.001,
                location.x() + 0.001,
                location.y() + 0.001,
            ),
        )?;

        if !restricted.is_empty() {
            println!(
                "   ⚠ {} at ({:.4}, {:.4}) is in restricted area: {}",
                drone,
                location.x(),
                location.y(),
                restricted[0].0.replace("restricted:", "")
            );
        } else {
            println!(
                "   ✓ {} at ({:.4}, {:.4}) is in safe area",
                drone,
                location.x(),
                location.y()
            );
        }
    }

    // ========================================
    // 8. Spatial Analytics
    // ========================================
    println!("\n8. Spatial Analytics");
    println!("---------------------");

    // Calculate coverage area
    let mut total_width = 0.0;
    let mut total_height = 0.0;
    let mut count = 0;

    let all_regions = vec![
        ("Manhattan", &manhattan),
        ("Brooklyn", &brooklyn),
        ("Queens", &queens),
        ("Bronx", &bronx),
        ("Staten Island", &staten_island),
    ];

    for (name, bbox) in &all_regions {
        total_width += bbox.width();
        total_height += bbox.height();
        count += 1;
        println!(
            "   {} coverage: {:.4}° × {:.4}°",
            name,
            bbox.width(),
            bbox.height()
        );
    }

    let avg_width = total_width / count as f64;
    let avg_height = total_height / count as f64;

    println!(
        "\n   Average borough size: {:.4}° × {:.4}°",
        avg_width, avg_height
    );

    // ========================================
    // 9. Database Statistics
    // ========================================
    println!("\n9. Database Statistics");
    println!("-----------------------");

    let stats = db.stats();
    println!("   Total keys: {}", stats.key_count);
    println!("   Total operations: {}", stats.operations_count);

    // Count different types of data
    let poi_count = manhattan_pois.len() + brooklyn_pois.len();
    println!("   Stored POIs: {}", poi_count);
    println!("   Stored regions: 5");
    println!("   Delivery zones: 3");
    println!("   Restricted zones: 2");

    println!("\n=== Bounding Box Database Integration Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Store and retrieve bounding boxes");
    println!("  • Query POIs within regions");
    println!("  • Find intersecting regions");
    println!("  • Delivery zone management");
    println!("  • Service area lookups");
    println!("  • Geofencing and restricted areas");
    println!("  • Spatial analytics");

    Ok(())
}

examples/bounding_boxes.rs (line 43)

fn main() -> Result<(), Box<dyn Error>> {
    println!("=== Spatio - Bounding Box Examples ===\n");

    // Create an in-memory database
    let mut db = Spatio::memory()?;
    println!("✓ Created in-memory database\n");

    // ========================================
    // 1. Basic 2D Bounding Box Operations
    // ========================================
    println!("1. Basic 2D Bounding Box");
    println!("-------------------------");

    // Create a bounding box for Manhattan
    let manhattan = BoundingBox2D::new(
        -74.0479, 40.6829, // Southwest corner (Battery Park)
        -73.9067, 40.8820, // Northeast corner (Inwood)
    );

    println!("   Manhattan bounding box:");
    println!(
        "     Min: ({:.4}, {:.4})",
        manhattan.min_x(),
        manhattan.min_y()
    );
    println!(
        "     Max: ({:.4}, {:.4})",
        manhattan.max_x(),
        manhattan.max_y()
    );
    println!(
        "     Center: ({:.4}, {:.4})",
        manhattan.center().x(),
        manhattan.center().y()
    );
    println!(
        "     Width: {:.4}°, Height: {:.4}°",
        manhattan.width(),
        manhattan.height()
    );

    // Check if points are within Manhattan
    let times_square = Point::new(-73.9855, 40.7580);
    let brooklyn_bridge = Point::new(-73.9969, 40.7061);
    let statue_of_liberty = Point::new(-74.0445, 40.6892);
    let jfk_airport = Point::new(-73.7781, 40.6413);

    println!("\n   Point containment checks:");
    println!(
        "     Times Square: {}",
        manhattan.contains_point(&times_square)
    );
    println!(
        "     Brooklyn Bridge: {}",
        manhattan.contains_point(&brooklyn_bridge)
    );
    println!(
        "     Statue of Liberty: {}",
        manhattan.contains_point(&statue_of_liberty)
    );
    println!(
        "     JFK Airport: {}",
        manhattan.contains_point(&jfk_airport)
    );

    // ========================================
    // 2. Bounding Box Intersection
    // ========================================
    println!("\n2. Bounding Box Intersection");
    println!("-----------------------------");

    // Create bounding boxes for different NYC boroughs
    let manhattan_bbox = BoundingBox2D::new(-74.0479, 40.6829, -73.9067, 40.8820);
    let brooklyn_bbox = BoundingBox2D::new(-74.0421, 40.5707, -73.8333, 40.7395);
    let queens_bbox = BoundingBox2D::new(-73.9626, 40.5431, -73.7004, 40.8007);

    println!(
        "   Manhattan ∩ Brooklyn: {}",
        manhattan_bbox.intersects(&brooklyn_bbox)
    );
    println!(
        "   Manhattan ∩ Queens: {}",
        manhattan_bbox.intersects(&queens_bbox)
    );
    println!(
        "   Brooklyn ∩ Queens: {}",
        brooklyn_bbox.intersects(&queens_bbox)
    );

    // ========================================
    // 3. Expanding Bounding Boxes
    // ========================================
    println!("\n3. Expanding Bounding Boxes");
    println!("----------------------------");

    let central_park = BoundingBox2D::new(-73.9812, 40.7644, -73.9492, 40.8003);
    println!("   Central Park original:");
    println!(
        "     Width: {:.4}°, Height: {:.4}°",
        central_park.width(),
        central_park.height()
    );

    // Expand by 0.01 degrees (~1 km)
    let expanded = central_park.expand(0.01);
    println!("\n   Expanded by 0.01°:");
    println!(
        "     Width: {:.4}°, Height: {:.4}°",
        expanded.width(),
        expanded.height()
    );
    println!(
        "     Growth: {:.4}° in each direction",
        (expanded.width() - central_park.width()) / 2.0
    );

    // ========================================
    // 4. 3D Bounding Boxes
    // ========================================
    println!("\n4. 3D Bounding Boxes");
    println!("--------------------");

    // Create a 3D bounding box for a tall building's footprint with height
    let one_world_trade = BoundingBox3D::new(
        -74.0134, 40.7127, 0.0, // Ground level southwest
        -74.0118, 40.7143, 541.0, // Top level northeast (541m height)
    );

    println!("   One World Trade Center:");
    println!(
        "     Footprint: {:.4}° × {:.4}°",
        one_world_trade.width(),
        one_world_trade.height()
    );
    println!("     Height: {:.1} meters", one_world_trade.depth());
    println!(
        "     Volume: {:.6} cubic degrees×meters",
        one_world_trade.volume()
    );

    let (cx, cy, cz) = one_world_trade.center();
    println!("     Center: ({:.4}, {:.4}, {:.1}m)", cx, cy, cz);

    // Check if points at different altitudes are within the building
    println!("\n   Altitude containment checks:");
    println!(
        "     Ground level (0m): {}",
        one_world_trade.contains_point(-74.0126, 40.7135, 0.0)
    );
    println!(
        "     Mid-level (270m): {}",
        one_world_trade.contains_point(-74.0126, 40.7135, 270.0)
    );
    println!(
        "     Top (540m): {}",
        one_world_trade.contains_point(-74.0126, 40.7135, 540.0)
    );
    println!(
        "     Above (600m): {}",
        one_world_trade.contains_point(-74.0126, 40.7135, 600.0)
    );

    // ========================================
    // 5. 3D to 2D Projection
    // ========================================
    println!("\n5. 3D to 2D Projection");
    println!("----------------------");

    let building_3d = BoundingBox3D::new(-74.0, 40.7, 0.0, -73.9, 40.8, 200.0);
    let building_2d = building_3d.to_2d();

    println!("   3D Bounding Box:");
    println!(
        "     Dimensions: {:.4}° × {:.4}° × {:.1}m",
        building_3d.width(),
        building_3d.height(),
        building_3d.depth()
    );

    println!("\n   Projected to 2D:");
    println!(
        "     Dimensions: {:.4}° × {:.4}°",
        building_2d.width(),
        building_2d.height()
    );

    // ========================================
    // 6. Temporal Bounding Boxes
    // ========================================
    println!("\n6. Temporal Bounding Boxes");
    println!("--------------------------");

    // Track how a delivery zone changes over time
    let morning_zone = BoundingBox2D::new(-74.01, 40.71, -73.99, 40.73);
    let afternoon_zone = BoundingBox2D::new(-74.02, 40.70, -73.98, 40.74);

    let morning_time = SystemTime::now();
    let afternoon_time = SystemTime::now();

    let temporal_morning = TemporalBoundingBox2D::new(morning_zone.clone(), morning_time);
    let temporal_afternoon = TemporalBoundingBox2D::new(afternoon_zone.clone(), afternoon_time);

    println!("   Morning delivery zone:");
    println!(
        "     Area: {:.4}° × {:.4}°",
        temporal_morning.bbox().width(),
        temporal_morning.bbox().height()
    );

    println!("\n   Afternoon delivery zone:");
    println!(
        "     Area: {:.4}° × {:.4}°",
        temporal_afternoon.bbox().width(),
        temporal_afternoon.bbox().height()
    );

    println!(
        "     Expansion: {:.4}° wider, {:.4}° taller",
        afternoon_zone.width() - morning_zone.width(),
        afternoon_zone.height() - morning_zone.height()
    );

    // ========================================
    // 7. Storing Bounding Boxes in Database
    // ========================================
    println!("\n7. Storing Bounding Boxes");
    println!("-------------------------");

    // Serialize and store bounding boxes
    let bbox_json = serde_json::to_vec(&manhattan)?;
    db.insert("zones:manhattan", bbox_json, None)?;

    let bbox3d_json = serde_json::to_vec(&one_world_trade)?;
    db.insert("buildings:wtc", bbox3d_json, None)?;

    println!("   ✓ Stored Manhattan bounding box");
    println!("   ✓ Stored One World Trade Center 3D box");

    // Retrieve and deserialize
    if let Some(data) = db.get("zones:manhattan")? {
        let retrieved: BoundingBox2D = serde_json::from_slice(&data)?;
        println!("\n   Retrieved Manhattan box:");
        println!(
            "     Center: ({:.4}, {:.4})",
            retrieved.center().x(),
            retrieved.center().y()
        );
    }

    // ========================================
    // 8. Practical Use Cases
    // ========================================
    println!("\n8. Practical Use Cases");
    println!("----------------------");

    // Geofencing
    let delivery_area = BoundingBox2D::new(-74.02, 40.70, -73.98, 40.75);
    let current_location = Point::new(-74.00, 40.72);

    if delivery_area.contains_point(&current_location) {
        println!("   ✓ Delivery driver is within service area");
    } else {
        println!("   ✗ Delivery driver is outside service area");
    }

    // Airspace management
    let airspace = BoundingBox3D::new(
        -74.1, 40.6, 0.0, // Ground level
        -73.8, 40.9, 3000.0, // 3000m ceiling
    );
    let drone_altitude = 150.0; // meters
    let drone_location = (-74.0, 40.75, drone_altitude);

    if airspace.contains_point(drone_location.0, drone_location.1, drone_location.2) {
        println!("   ✓ Drone is within authorized airspace");
    }

    // Region overlap detection
    let zone_a = BoundingBox2D::new(-74.05, 40.70, -74.00, 40.75);
    let zone_b = BoundingBox2D::new(-74.02, 40.72, -73.97, 40.77);

    if zone_a.intersects(&zone_b) {
        println!("   ⚠ Service zones A and B overlap - coordination needed");
    }

    println!("\n=== Bounding Box Examples Complete! ===");
    println!("\nKey Features Demonstrated:");
    println!("  • Create and manipulate 2D/3D bounding boxes");
    println!("  • Check point containment");
    println!("  • Detect box intersections");
    println!("  • Expand regions");
    println!("  • Project 3D to 2D");
    println!("  • Track temporal changes");
    println!("  • Serialize and store in database");
    println!("  • Geofencing and airspace management");

    Ok(())
}

pub fn lon(&self) -> f64

Get the longitude (alias for x).

pub fn lat(&self) -> f64

Get the latitude (alias for y).

pub fn inner(&self) -> &Point

Access the inner geo::Point.

pub fn into_inner(self) -> Point

Convert into the inner geo::Point.

pub fn haversine_distance(&self, other: &Point) -> f64

Calculate haversine distance to another point in meters.

Uses the haversine formula which accounts for Earth’s curvature.

Examples

use spatio_types::geo::Point;

let nyc = Point::new(-74.0060, 40.7128);
let la = Point::new(-118.2437, 34.0522);
let distance = nyc.haversine_distance(&la);
assert!(distance > 3_900_000.0); // ~3,944 km

pub fn geodesic_distance(&self, other: &Point) -> f64

Calculate geodesic distance to another point in meters.

Uses the Vincenty formula which is more accurate than haversine but slightly slower.

Examples

use spatio_types::geo::Point;

let p1 = Point::new(-74.0060, 40.7128);
let p2 = Point::new(-74.0070, 40.7138);
let distance = p1.geodesic_distance(&p2);

pub fn euclidean_distance(&self, other: &Point) -> f64

Calculate euclidean distance to another point.

This calculates straight-line distance in the coordinate space, which is only accurate for small distances.

Examples

use spatio_types::geo::Point;

let p1 = Point::new(0.0, 0.0);
let p2 = Point::new(3.0, 4.0);
let distance = p1.euclidean_distance(&p2);
assert_eq!(distance, 5.0); // 3-4-5 triangle

pub fn to_geojson(&self) -> Result<String, GeoJsonError>

Convert to GeoJSON string representation.

Examples

use spatio_types::geo::Point;

let point = Point::new(-74.0060, 40.7128);
let json = point.to_geojson().unwrap();
assert!(json.contains("Point"));

pub fn from_geojson(geojson: &str) -> Result<Point, GeoJsonError>

Parse from GeoJSON string.

Examples

use spatio_types::geo::Point;

let json = r#"{"type":"Point","coordinates":[-74.006,40.7128]}"#;
let point = Point::from_geojson(json).unwrap();
assert_eq!(point.x(), -74.006);

Trait Implementations

impl Clone for Point

fn clone(&self) -> Point

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Point

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Point

fn deserialize<__D>( __deserializer: __D, ) -> Result<Point, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<(f64, f64)> for Point

fn from(_: (f64, f64)) -> Point

Converts to this type from the input type.

impl From<Point> for Point

fn from(point: Point) -> Point

Converts to this type from the input type.

impl PartialEq for Point

fn eq(&self, other: &Point) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Point

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Point

impl StructuralPartialEq for Point