Struct arcs::primitives::Arc

pub struct Arc<S> { /* fields omitted */ }

A circle segment.

Implementations

impl<S> Arc<S>

pub fn from_centre_radius(
    centre: Point2D<f64, S>,
    radius: f64,
    start_angle: Angle<f64>,
    sweep_angle: Angle<f64>
) -> Arc<S>

Create an Arc based upon its centre and radius.

Examples

pub fn from_three_points(
    start: Point2D<f64, S>,
    middle: Point2D<f64, S>,
    end: Point2D<f64, S>
) -> Option<Arc<S>>

Try to find the Arc which will pass through three points.

Examples

You can use this constructor in the normal way.

use arcs_core::primitives::Arc;

let right = Point::new(10.0, 0.0);
let above = Point::new(0.0, 10.0);
let left = Point::new(-10.0, 0.0);

let got = Arc::from_three_points(right, above, left).unwrap();

assert_eq!(got.centre(), Point::zero());
assert_eq!(got.radius(), 10.0);
assert!(got.is_anticlockwise());

This will fail if the three points are Orientation::Collinear.

use arcs_core::primitives::Arc;

let start = Point::new(0.0, 0.0);
let middle = Point::new(10.0, 0.0);
let end = Point::new(20.0, 0.0);

let got = Arc::from_three_points(start, middle, end);

assert!(got.is_none());

pub const fn centre(self) -> Point2D<f64, S>

The Arc's centre point.

pub const fn radius(self) -> f64

The Arc's radius.

pub const fn start_angle(self) -> Angle<f64>

pub const fn sweep_angle(self) -> Angle<f64>

pub fn end_angle(self) -> Angle<f64>

pub fn is_anticlockwise(self) -> bool

pub fn is_clockwise(self) -> bool

pub fn start(self) -> Point2D<f64, S>

pub fn end(self) -> Point2D<f64, S>

pub fn point_at(self, angle: Angle<f64>) -> Point2D<f64, S>

pub fn contains_angle(self, angle: Angle<f64>) -> bool

pub fn is_minor_arc(&self) -> bool

pub fn is_major_arc(&self) -> bool

Trait Implementations

impl<Space> Approximate<Space> for Arc<Space>

type Iter = ApproximatedArc<Space>

An iterator over the approximated vertices.

fn approximate(
    &self,
    tolerance: f64
) -> <Arc<Space> as Approximate<Space>>::Iter

Approximate the shape, ensuring the resulting path is within tolerance units of the original.

impl<S> Bounded<S> for Arc<S>

fn bounding_box(&self) -> BoundingBox<S>

Calculate the approximate location this object is located in.

impl<S> Clone for Arc<S>

fn clone(&self) -> Arc<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Space> ClosestPoint<Space> for Arc<Space>

fn closest_point(&self, target: Point2D<f64, Space>) -> Closest<Space>

Calculate the closest point to target.

impl<S> Copy for Arc<S>

impl<S> Debug for Arc<S> where
    S: Debug, 

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

Formats the value using the given formatter.

impl<Space> Length for Arc<Space>

fn length(&self) -> f64

Calculates the length of an Arc.

let radius = 50.0;
let arc = Arc::from_centre_radius(
    Point::zero(),
    radius,
    Angle::zero(),
    Angle::two_pi(),
);

assert_eq!(arc.length(), 2.0 * radius * PI);

impl<S> PartialEq<Arc<S>> for Arc<S> where
    S: PartialEq<S>, 

fn eq(&self, other: &Arc<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Arc<S>) -> bool

This method tests for !=.

impl<Space> Scale for Arc<Space>

fn scale(&mut self, scale_factor: f64)

Scale the object in-place.

fn scaled(&self, scale_factor: f64) -> Self where
    Self: Clone, 

Convenience method for getting a scaled copy of this object.

impl<S> StructuralPartialEq for Arc<S>

impl<Space> Translate<Space> for Arc<Space>

fn translate(&mut self, displacement: Vector2D<f64, Space>)

Translate this object in-place.

fn translated(&self, displacement: Vector2D<f64, Space>) -> Self where
    Self: Clone, 

A convenience method for getting a translated copy of this object.