Struct Point3d 

pub struct Point3d {
    pub point: Point,
    pub z: f64,
}

A 3D geographic point with x, y (longitude/latitude) and z (altitude/elevation).

This type represents a point in 3D space, typically used for altitude-aware geospatial applications like drone tracking, aviation, or multi-floor buildings.

Examples

use spatio_types::point::Point3d;
use spatio_types::geo::Point;

// Create a 3D point for a drone at 100 meters altitude
let drone_position = Point3d::new(-74.0060, 40.7128, 100.0);
assert_eq!(drone_position.altitude(), 100.0);

// Calculate 3D distance to another point
let other = Point3d::new(-74.0070, 40.7138, 150.0);
let distance = drone_position.distance_3d(&other);

Fields

point: Point

The 2D geographic point (longitude/latitude or x/y)

z: f64

The altitude/elevation/z-coordinate (in meters typically)

Implementations

impl Point3d

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

Create a new 3D point from x, y, and z coordinates.

Arguments

• x - Longitude or x-coordinate
• y - Latitude or y-coordinate
• z - Altitude/elevation in meters

Examples

use spatio_types::point::Point3d;

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

pub fn from_point_and_altitude(point: Point, z: f64) -> Self

Create a 3D point from a 2D point and altitude.

pub fn x(&self) -> f64

Get the x coordinate (longitude).

pub fn y(&self) -> f64

Get the y coordinate (latitude).

pub fn z(&self) -> f64

Get the z coordinate (altitude/elevation).

pub fn altitude(&self) -> f64

Get the altitude (alias for z()).

pub fn point_2d(&self) -> &Point

Get a reference to the underlying 2D point.

pub fn to_2d(&self) -> Point

Project this 3D point to 2D by discarding the z coordinate.

pub fn distance_3d(&self, other: &Point3d) -> f64

Calculate the 3D Euclidean distance to another 3D point.

This calculates the straight-line distance in 3D space using the Pythagorean theorem.

Examples

use spatio_types::point::Point3d;

let p1 = Point3d::new(0.0, 0.0, 0.0);
let p2 = Point3d::new(3.0, 4.0, 12.0);
let distance = p1.distance_3d(&p2);
assert_eq!(distance, 13.0); // 3-4-5 triangle extended to 3D

pub fn haversine_distances(&self, other: &Point3d) -> (f64, f64, f64)

Calculate all distance components at once (horizontal, altitude, 3D).

This is more efficient than calling haversine_2d and haversine_3d separately as it calculates the haversine formula only once.

Returns

Tuple of (horizontal_distance, altitude_difference, distance_3d) in meters.

Examples

use spatio_types::point::Point3d;

let p1 = Point3d::new(-74.0060, 40.7128, 0.0);
let p2 = Point3d::new(-74.0070, 40.7138, 100.0);
let (h_dist, alt_diff, dist_3d) = p1.haversine_distances(&p2);

pub fn haversine_3d(&self, other: &Point3d) -> f64

Calculate the haversine distance combined with altitude difference.

This uses the haversine formula for the horizontal distance (considering Earth’s curvature) and combines it with the altitude difference using the Pythagorean theorem.

Returns

Distance in meters.

Examples

use spatio_types::point::Point3d;

let p1 = Point3d::new(-74.0060, 40.7128, 0.0);    // NYC sea level
let p2 = Point3d::new(-74.0070, 40.7138, 100.0);  // Nearby, 100m up
let distance = p1.haversine_3d(&p2);

pub fn haversine_2d(&self, other: &Point3d) -> f64

Calculate the haversine distance on the 2D plane (ignoring altitude).

Returns

Distance in meters.

pub fn altitude_difference(&self, other: &Point3d) -> f64

Get the altitude difference to another point.

Trait Implementations

impl Clone for Point3d

fn clone(&self) -> Point3d

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Point3d

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Point3d

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Point3d

fn eq(&self, other: &Point3d) -> 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 Point3d

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Point3d