Struct CheapRuler 

pub struct CheapRuler<T>
where
    T: Float + Debug,
{ /* private fields */ }

A collection of very fast approximations to common geodesic measurements. Useful for performance-sensitive code that measures things on a city scale. Point coordinates are in the [x = longitude, y = latitude] form.

Implementations

impl<T> CheapRuler<T>

where T: Float + Debug,

pub fn new(latitude: T, distance_unit: DistanceUnit) -> Self

pub fn from_tile(y: u32, z: u32, distance_unit: DistanceUnit) -> Self

Creates a ruler object from tile coordinates (y and z). Convenient in tile-reduce scripts

Arguments

• y - y
• z - z
• distance_unit - Unit to express distances in

Examples

use cheap_ruler::{CheapRuler, DistanceUnit};
let cr = CheapRuler::<f64>::from_tile(1567, 12, DistanceUnit::Meters);

pub fn square_distance(&self, a: &Point<T>, b: &Point<T>) -> T

Calculates the square of the approximate distance between two geographical points

Arguments

• a - First point
• b - Second point

pub fn distance(&self, a: &Point<T>, b: &Point<T>) -> T

Calculates the approximate distance between two geographical points

Arguments

• a - First point
• b - Second point

Examples

use cheap_ruler::{CheapRuler, DistanceUnit};
let cr = CheapRuler::new(44.7192003, DistanceUnit::Meters);
let dist = cr.distance(
  &(14.8901816, 44.7209699).into(),
  &(14.8905188, 44.7209699).into()
);
assert!(dist < 38.0);

pub fn bearing(&self, a: &Point<T>, b: &Point<T>) -> T

Returns the bearing between two points in angles

Arguments

• a - First point
• b - Second point

Examples

use cheap_ruler::{CheapRuler, DistanceUnit};
let cr = CheapRuler::new(44.7192003, DistanceUnit::Meters);
let bearing = cr.bearing(
  &(14.8901816, 44.7209699).into(),
  &(14.8905188, 44.7209699).into()
);
assert_eq!(bearing, 90.0);

pub fn destination(&self, origin: &Point<T>, dist: T, bearing: T) -> Point<T>

Returns a new point given distance and bearing from the starting point

Arguments

• origin - origin point
• dist - distance
• bearing - bearing

Examples

use cheap_ruler::{CheapRuler, DistanceUnit};
let cr = CheapRuler::new(44.7192003, DistanceUnit::Meters);
let p1 = (14.8901816, 44.7209699).into();
let p2 = (14.8905188, 44.7209699).into();
let dist = cr.distance(&p1, &p2);
let bearing = cr.bearing(&p1, &p2);
let destination = cr.destination(&p1, dist, bearing);

assert_eq!(destination.x(), p2.x());
assert_eq!(destination.y(), p2.y());

pub fn offset(&self, origin: &Point<T>, dx: T, dy: T) -> Point<T>

Returns a new point given easting and northing offsets (in ruler units) from the starting point

Arguments

• origin - point
• dx - easting
• dy - northing

pub fn line_distance(&self, points: &LineString<T>) -> T

Given a line (an array of points), returns the total line distance.

Arguments

• points - line of points

Example

use cheap_ruler::{CheapRuler, DistanceUnit};
use geo_types::LineString;
let cr = CheapRuler::new(50.458, DistanceUnit::Meters);
let line_string: LineString<f64> = vec![
    (-67.031, 50.458),
    (-67.031, 50.534),
    (-66.929, 50.534),
    (-66.929, 50.458)
].into();
let length = cr.line_distance(&line_string);

pub fn area(&self, polygon: &Polygon<T>) -> T

Given a polygon returns the area

• polygon - Polygon

pub fn along(&self, line: &LineString<T>, dist: T) -> Option<Point<T>>

Returns the point at a specified distance along the line

Arguments

• line - Line
• dist - Distance along the line

pub fn point_to_segment_distance( &self, p: &Point<T>, start: &Point<T>, end: &Point<T>, ) -> T

Returns the shortest distance between a point and a line segment given with two points.

Arguments

• p - Point to calculate the distance from
• start - Start point of line segment
• end - End point of line segment

pub fn point_on_line( &self, line: &LineString<T>, point: &Point<T>, ) -> Option<PointOnLine<T>>

Returns a tuple of the form (point, index, t) where point is closest point on the line from the given point, index is the start index of the segment with the closest point, and t is a parameter from 0 to 1 that indicates where the closest point is on that segment

Arguments

• line - Line to compare with point
• point - Point to calculate the closest point on the line

pub fn line_slice( &self, start: &Point<T>, stop: &Point<T>, line: &LineString<T>, ) -> LineString<T>

Returns a part of the given line between the start and the stop points (or their closest points on the line)

Arguments

• start - Start point
• stop - Stop point
• line - Line string

pub fn line_slice_along( &self, start: T, stop: T, line: &LineString<T>, ) -> LineString<T>

Returns a part of the given line between the start and the stop points indicated by distance along the line

• start - Start distance
• stop - Stop distance
• line - Line string

pub fn buffer_point(&self, p: &Point<T>, buffer: T) -> Rect<T>

Given a point, returns a bounding rectangle created from the given point buffered by a given distance

Arguments

• p - Point
• buffer - Buffer distance

pub fn buffer_bbox(&self, bbox: &Rect<T>, buffer: T) -> Rect<T>

Given a bounding box, returns the box buffered by a given distance

Arguments

• bbox - Bounding box
• buffer - Buffer distance

pub fn inside_bbox(&self, p: &Point<T>, bbox: &Rect<T>) -> bool

Returns true if the given point is inside in the given bounding box, otherwise false.

Arguments

• p - Point
• bbox - Bounding box

Trait Implementations

impl<T> Clone for CheapRuler<T>

where T: Float + Debug + Clone,

fn clone(&self) -> CheapRuler<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for CheapRuler<T>

where T: Float + Debug + Debug,

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

Formats the value using the given formatter.

impl<T> PartialEq for CheapRuler<T>

where T: Float + Debug + PartialEq,

fn eq(&self, other: &CheapRuler<T>) -> 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<T> StructuralPartialEq for CheapRuler<T>

where T: Float + Debug,