# Crate kurbo

Expand description

2D geometry, with a focus on curves.

The kurbo library contains data structures and algorithms for curves and vector paths. It was designed to serve the needs of 2D graphics applications, but it is intended to be general enough to be useful for other applications.

Kurbo is designed to be used by `Piet`, a crate for drawing 2D graphics, and is in turn used by `Druid`, a cross-platform GUI toolkit.

## Examples

Basic UI-style geometry:

``````use kurbo::{Insets, Point, Rect, Size, Vec2};

let pt = Point::new(10.0, 10.0);
let vector = Vec2::new(5.0, -5.0);
let pt2 = pt + vector;
assert_eq!(pt2, Point::new(15.0, 5.0));

let rect = Rect::from_points(pt, pt2);
assert_eq!(rect, Rect::from_origin_size((10.0, 5.0), (5.0, 5.0)));

let insets = Insets::uniform(1.0);
let inset_rect = rect - insets;
assert_eq!(inset_rect.size(), Size::new(3.0, 3.0));``````

Finding the closest position on a `Shape`’s perimeter to a `Point`:

``````use kurbo::{Circle, ParamCurve, ParamCurveNearest, Point, Shape};

const DESIRED_ACCURACY: f64 = 0.1;

/// Given a shape and a point, returns the closest position on the shape's
/// perimeter, or `None` if the shape is malformed.
fn closest_perimeter_point(shape: impl Shape, pt: Point) -> Option<Point> {
let mut best: Option<(Point, f64)> = None;
for segment in shape.path_segments(DESIRED_ACCURACY) {
let nearest = segment.nearest(pt, DESIRED_ACCURACY);
if best.map(|(_, best_d)| nearest.distance_sq < best_d).unwrap_or(true) {
best = Some((segment.eval(nearest.t), nearest.distance_sq))
}
}
best.map(|(point, _)| point)
}

let circle = Circle::new((5.0, 5.0), 5.0);
let hit_point = Point::new(5.0, -2.0);
let expectation = Point::new(5.0, 0.0);
let hit = closest_perimeter_point(circle, hit_point).unwrap();
assert!(hit.distance(expectation) <= DESIRED_ACCURACY);``````

## Features

This crate either uses the standard library or the `libm` crate for math functionality. The `std` feature is enabled by default, but can be disabled, as long as the `libm` feature is enabled. This is useful for `no_std` environments. However, note that the `libm` crate is not as efficient as the standard library, and that this crate still uses the `alloc` crate regardless.

## Modules

• Common mathematical operations
• Computation of offset curves of cubic Béziers, based on a curve fitting approach.
• Simplification of a Bézier path.

## Enums

• The element of a Bézier path.
• A segment of a Bézier path.
• An error which can be returned when parsing an SVG.

## Constants

• A default value for methods that take an ‘accuracy’ argument.
• The maximum number of extrema that can be reported in the `ParamCurveExtrema` trait.

## Functions

• Convert multiple cubic Bézier curves to quadratic splines.
• Generate a Bézier path that fits the source curve.
• Generate a highly optimized Bézier path that fits the source curve.
• Fit a single cubic to a range of the source curve.
• Flatten the path, invoking the callback repeatedly.
• Transform an iterator over path elements into one over path segments.