Struct Point 

pub struct Point {
    pub x: f64,
    pub y: f64,
}

A 2D point.

This type represents a point in 2D space. It has the same layout as Vec2, but its meaning is different: Vec2 represents a change in location (for example velocity).

In general, kurbo overloads math operators where it makes sense, for example implementing Affine * Point as the point under the affine transformation. However Point + Point and f64 * Point are not implemented, because the operations do not make geometric sense. If you need to apply these operations, then 1) check what you’re doing makes geometric sense, then 2) use Point::to_vec2 to convert the point to a Vec2.

Fields

x: f64

The x coordinate.

y: f64

The y coordinate.

Implementations

impl Point

pub const ZERO: Point

The point (0, 0).

pub const ORIGIN: Point

The point at the origin; (0, 0).

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

Create a new Point with the provided x and y coordinates.

Examples found in repository

examples/shapes_demo.rs (lines 27-30)

fn cell_center(idx: usize) -> Point {
    let col = idx % GRID_COLS;
    let row = idx / GRID_COLS;
    Point::new(
        GRID_LEFT + CELL_W * (col as f64 + 0.5),
        GRID_TOP + CELL_H * (row as f64 + 0.5),
    )
}

fn draw_shape_centered(
    scene: &mut impl SceneBuilder,
    shape: &Shape,
    center: Point,
    size: f64,
    brush: &Brush,
    stroke_world_width: f64,
) {
    let xform = Affine::translate(center.to_vec2()) * Affine::scale(size);
    let (paths, style) = match shape.kind() {
        ShapeKind::Paths { paths, style } => (paths, style),
        ShapeKind::Glyph { .. } => return,
    };
    match style {
        ShapeStyle::Fill => {
            for sub in paths {
                scene.fill(FillRule::NonZero, xform, brush, None, sub, PickId::Skip);
            }
        }
        ShapeStyle::Stroke => {
            let stroke = Stroke::new(stroke_world_width / size)
                .with_caps(Cap::Round)
                .with_join(Join::Round);
            for sub in paths {
                scene.stroke(&stroke, xform, brush, None, sub, PickId::Skip);
            }
        }
    }
}

fn draw_shape_attached(
    scene: &mut impl SceneBuilder,
    shape: &Shape,
    placement: Point,
    direction: Vec2,
    size: f64,
    brush: &Brush,
    stroke_world_width: f64,
) {
    let perp = Vec2::new(-direction.y, direction.x);
    let a = shape.anchor();
    let anchor_world = direction * (a.x * size) + perp * (a.y * size);
    let origin = placement - anchor_world;
    let xform = Affine::translate(origin.to_vec2())
        * Affine::rotate(direction.atan2())
        * Affine::scale(size);
    let (paths, style) = match shape.kind() {
        ShapeKind::Paths { paths, style } => (paths, style),
        ShapeKind::Glyph { .. } => return,
    };
    match style {
        ShapeStyle::Fill => {
            for sub in paths {
                scene.fill(FillRule::NonZero, xform, brush, None, sub, PickId::Skip);
            }
        }
        ShapeStyle::Stroke => {
            let stroke = Stroke::new(stroke_world_width / size)
                .with_caps(Cap::Round)
                .with_join(Join::Round);
            for sub in paths {
                scene.stroke(&stroke, xform, brush, None, sub, PickId::Skip);
            }
        }
    }
}

fn main() {
    let mut renderer = VelloRenderer::new().expect("vello renderer init");
    let registry = ShapeRegistry::with_builtins();

    let glyph_brush: Brush = rgb8(60, 130, 220).into();
    let chrome_brush: Brush = rgb8(80, 84, 96).into();
    let line_brush: Brush = rgb8(190, 195, 205).into();

    let glyph_world_stroke = 2.0;
    let line_stroke = Stroke::new(2.5).with_caps(Cap::Butt);
    let cell_stroke = Stroke::new(1.0);

    {
        let scene = renderer.scene();

        for (i, name) in builtin::NAMES.iter().enumerate() {
            let center = cell_center(i);
            let cell = Rect::new(
                center.x - CELL_W * 0.5 + 2.0,
                center.y - CELL_H * 0.5 + 2.0,
                center.x + CELL_W * 0.5 - 2.0,
                center.y + CELL_H * 0.5 - 2.0,
            )
            .to_path(0.1);
            scene.stroke(
                &cell_stroke,
                Affine::IDENTITY,
                &chrome_brush,
                None,
                &cell,
                PickId::Skip,
            );

            let shape = registry.get(name).expect("registered");
            draw_shape_centered(scene, shape, center, 28.0, &glyph_brush, glyph_world_stroke);
        }

        let demos: &[(&str, f64)] = &[
            ("arrow-closed", 18.0),
            ("arrow-stealth", 22.0),
            ("arrow-open", 18.0),
            ("arrow-feather", 28.0),
            ("arrow-dot", 14.0),
        ];
        let demo_top = GRID_TOP + (GRID_ROWS as f64) * CELL_H + 25.0;
        let demo_spacing = 28.0;
        let x_start = 60.0;
        let x_end = (W as f64) - 60.0;

        for (i, &(name, size)) in demos.iter().enumerate() {
            let y = demo_top + (i as f64) * demo_spacing;
            let start = Point::new(x_start, y);
            let end = Point::new(x_end, y);

            let direction = (end - start).normalize();
            let shape = registry.get(name).expect("registered");

            let mut line = hephaestus::Path::new();
            line.move_to(start);
            line.line_to(end);
            scene.stroke(
                &line_stroke,
                Affine::IDENTITY,
                &line_brush,
                None,
                &line,
                PickId::Skip,
            );

            draw_shape_attached(
                scene,
                shape,
                end,
                direction,
                size,
                &glyph_brush,
                glyph_world_stroke,
            );
        }
    }

    let mut pixels = vec![0u8; (W * H * 4) as usize];
    let bg: Color = rgb8(20, 22, 28);
    renderer
        .render_to_buffer(W, H, bg, &mut pixels)
        .expect("render");

    let path = std::env::current_dir()
        .unwrap()
        .join("examples/shapes_demo.png");
    hephaestus::image::write_png(&path, W, H, &pixels).expect("write png");
    println!("wrote {}", path.display());
}

examples/hello.rs (line 35)

fn main() {
    let mut renderer = VelloRenderer::new().expect("vello renderer init");
    let (w, h) = (512u32, 512u32);

    {
        let scene = renderer.scene();

        // 1. Filled rectangle (solid brush)
        let rect = Rect::new(40.0, 40.0, 240.0, 200.0).to_path(0.1);
        let solid: Brush = rgb8(60, 120, 200).into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &solid,
            None,
            &rect,
            PickId::Skip,
        );

        // 2. Stroked open polyline with round caps/joins
        let mut poly = Path::new();
        poly.move_to(Point::new(60.0, 300.0));
        poly.line_to(Point::new(140.0, 360.0));
        poly.line_to(Point::new(200.0, 280.0));
        poly.line_to(Point::new(260.0, 380.0));
        let stroke = Stroke::new(8.0)
            .with_caps(Cap::Round)
            .with_join(Join::Round);
        let line_brush: Brush = rgb8(220, 220, 220).into();
        scene.stroke(
            &stroke,
            Affine::IDENTITY,
            &line_brush,
            None,
            &poly,
            PickId::Skip,
        );

        // 3. Gradient-filled circle
        let circle = kurbo::Circle::new(Point::new(380.0, 150.0), 90.0).to_path(0.1);
        let gradient = Gradient::new_linear(Point::new(290.0, 60.0), Point::new(470.0, 240.0))
            .with_stops([rgb(0.95, 0.55, 0.15), rgb(0.15, 0.05, 0.45)].as_slice());
        let grad_brush: Brush = gradient.into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &grad_brush,
            None,
            &circle,
            PickId::Skip,
        );

        // 4. Multiply layer with a translucent square overlapping the rect
        let layer_clip = Rect::new(0.0, 0.0, w as f64, h as f64).to_path(0.1);
        scene.push_layer(
            BlendMode::new(Mix::Multiply, Compose::SrcOver),
            1.0,
            Affine::IDENTITY,
            &layer_clip,
        );
        let overlap = Rect::new(160.0, 120.0, 360.0, 320.0).to_path(0.1);
        let overlap_brush: Brush = rgba(1.0, 0.85, 0.2, 0.7).into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &overlap_brush,
            None,
            &overlap,
            PickId::Skip,
        );
        scene.pop_layer();
    }

    let mut pixels = vec![0u8; (w * h * 4) as usize];
    let bg: Color = rgb8(20, 22, 28);
    renderer
        .render_to_buffer(w, h, bg, &mut pixels)
        .expect("render");

    let path = std::env::current_dir().unwrap().join("examples/hello.png");
    hephaestus::image::write_png(&path, w, h, &pixels).expect("write png");
    println!("wrote {}", path.display());
}

examples/hello_hybrid.rs (line 37)

fn main() {
    let mut renderer = HybridRenderer::new().expect("hybrid renderer init");
    let (w, h) = (512u32, 512u32);

    {
        let scene = renderer.scene();

        // 1. Filled rectangle (solid brush)
        let rect = Rect::new(40.0, 40.0, 240.0, 200.0).to_path(0.1);
        let solid: Brush = rgb8(60, 120, 200).into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &solid,
            None,
            &rect,
            PickId::Skip,
        );

        // 2. Stroked open polyline with round caps/joins
        let mut poly = Path::new();
        poly.move_to(Point::new(60.0, 300.0));
        poly.line_to(Point::new(140.0, 360.0));
        poly.line_to(Point::new(200.0, 280.0));
        poly.line_to(Point::new(260.0, 380.0));
        let stroke = Stroke::new(8.0)
            .with_caps(Cap::Round)
            .with_join(Join::Round);
        let line_brush: Brush = rgb8(220, 220, 220).into();
        scene.stroke(
            &stroke,
            Affine::IDENTITY,
            &line_brush,
            None,
            &poly,
            PickId::Skip,
        );

        // 3. Gradient-filled circle
        let circle = kurbo::Circle::new(Point::new(380.0, 150.0), 90.0).to_path(0.1);
        let gradient = Gradient::new_linear(Point::new(290.0, 60.0), Point::new(470.0, 240.0))
            .with_stops([rgb(0.95, 0.55, 0.15), rgb(0.15, 0.05, 0.45)].as_slice());
        let grad_brush: Brush = gradient.into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &grad_brush,
            None,
            &circle,
            PickId::Skip,
        );

        // 4. Multiply layer with a translucent square overlapping the rect
        let layer_clip = Rect::new(0.0, 0.0, w as f64, h as f64).to_path(0.1);
        scene.push_layer(
            BlendMode::new(Mix::Multiply, Compose::SrcOver),
            1.0,
            Affine::IDENTITY,
            &layer_clip,
        );
        let overlap = Rect::new(160.0, 120.0, 360.0, 320.0).to_path(0.1);
        let overlap_brush: Brush = rgba(1.0, 0.85, 0.2, 0.7).into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &overlap_brush,
            None,
            &overlap,
            PickId::Skip,
        );
        scene.pop_layer();
    }

    let mut pixels = vec![0u8; (w * h * 4) as usize];
    let bg: Color = rgb8(20, 22, 28);
    renderer
        .render_to_buffer(w, h, bg, &mut pixels)
        .expect("render");

    let path = std::env::current_dir()
        .unwrap()
        .join("examples/hello_hybrid.png");
    hephaestus::image::write_png(&path, w, h, &pixels).expect("write png");
    println!("wrote {}", path.display());
}

examples/primitives_demo.rs (line 33)

fn main() {
    let mut renderer = VelloRenderer::new().expect("vello renderer init");
    let (w, h) = (640u32, 800u32);

    {
        let scene = renderer.scene();
        let reference_brush: Brush = rgb8(80, 80, 80).into();
        let dotted = Stroke::new(1.0).with_dashes(0.0, vec![3.0, 4.0]);

        // ---------- strip 1: end-clipped, corner-rounded polyline ----------

        let node_a_center = Point::new(120.0, 140.0);
        let node_a_radius = 40.0;
        let node_b = Rect::new(440.0, 100.0, 580.0, 180.0);

        let node_brush: Brush = rgb8(60, 90, 140).into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &node_brush,
            None,
            &kurbo::Circle::new(node_a_center, node_a_radius).to_path(0.1),
            PickId::Skip,
        );
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &node_brush,
            None,
            &node_b.to_path(0.1),
            PickId::Skip,
        );

        let raw = [
            node_a_center,
            Point::new(220.0, 60.0),
            Point::new(340.0, 220.0),
            Point::new(420.0, 80.0),
            Point::new(node_b.center().x, node_b.center().y),
        ];
        let clipped = clip_polyline(
            &raw,
            Some(EndClip::Circle {
                center: node_a_center,
                radius: node_a_radius,
            }),
            Some(EndClip::Rect(node_b)),
        );
        let connector = round_corners(
            &clipped,
            false,
            CornerRounding {
                max_cut: 30.0,
                ..Default::default()
            },
        );
        let line_stroke = Stroke::new(4.0)
            .with_caps(Cap::Round)
            .with_join(Join::Round);
        let line_brush: Brush = rgb8(230, 200, 120).into();
        scene.stroke(
            &line_stroke,
            Affine::IDENTITY,
            &line_brush,
            None,
            &connector,
            PickId::Skip,
        );
        scene.stroke(
            &dotted,
            Affine::IDENTITY,
            &reference_brush,
            None,
            &mk_polyline(&raw),
            PickId::Skip,
        );

        // ---------- strip 2: polygon-with-hole, offset + rounded ----------

        let outer = [
            Point::new(120.0, 320.0),
            Point::new(520.0, 320.0),
            Point::new(520.0, 500.0),
            Point::new(120.0, 500.0),
        ];
        let hole = [
            Point::new(240.0, 370.0),
            Point::new(400.0, 370.0),
            Point::new(400.0, 450.0),
            Point::new(240.0, 450.0),
        ];
        let rings: [&[Point]; 2] = [&outer, &hole];

        let plain = polygon(&rings, PolygonOptions::default());
        scene.stroke(
            &dotted,
            Affine::IDENTITY,
            &reference_brush,
            None,
            &plain,
            PickId::Skip,
        );

        let inflated_rings = offset_polygon(&rings, 15.0, 4.0);
        let mut inflated = Path::new();
        for r in &inflated_rings {
            let sub = round_corners(r, true, CornerRounding::default());
            for el in sub.iter() {
                inflated.push(el);
            }
        }
        let fill_brush: Brush = rgb8(180, 70, 90).into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &fill_brush,
            None,
            &inflated,
            PickId::Skip,
        );

        // ---------- strip 3: wedge & annular wedge with curve-aware rounding ----------

        // Left: wedge with rounded line-to-arc corners.
        let w_center = Point::new(170.0, 680.0);
        let w_radius = 90.0;
        let plain_wedge = wedge(w_center, w_radius, -PI / 2.0 - PI / 5.0, PI * 2.0 / 5.0);
        scene.stroke(
            &dotted,
            Affine::IDENTITY,
            &reference_brush,
            None,
            &plain_wedge,
            PickId::Skip,
        );
        let rounded_wedge = round_path_corners(
            &plain_wedge,
            CornerRounding {
                max_cut: 18.0,
                ..Default::default()
            },
        );
        let wedge_brush: Brush = rgb8(110, 160, 90).into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &wedge_brush,
            None,
            &rounded_wedge,
            PickId::Skip,
        );

        // Right: annular wedge with all four corners rounded.
        let a_center = Point::new(450.0, 680.0);
        let plain_aw = annular_wedge(a_center, 35.0, 100.0, -PI / 2.0 - PI / 4.0, PI / 2.0);
        scene.stroke(
            &dotted,
            Affine::IDENTITY,
            &reference_brush,
            None,
            &plain_aw,
            PickId::Skip,
        );
        let rounded_aw = round_path_corners(
            &plain_aw,
            CornerRounding {
                max_cut: 14.0,
                ..Default::default()
            },
        );
        let aw_brush: Brush = rgb8(180, 130, 90).into();
        scene.fill(
            FillRule::NonZero,
            Affine::IDENTITY,
            &aw_brush,
            None,
            &rounded_aw,
            PickId::Skip,
        );
    }

    let mut pixels = vec![0u8; (w * h * 4) as usize];
    let bg: Color = rgb8(20, 22, 28);
    renderer
        .render_to_buffer(w, h, bg, &mut pixels)
        .expect("render");

    let path = std::env::current_dir()
        .unwrap()
        .join("examples/primitives_demo.png");
    hephaestus::image::write_png(&path, w, h, &pixels).expect("write png");
    println!("wrote {}", path.display());
}

examples/ribbon_gradient.rs (line 51)

fn main() {
    let dpi = 96.0;
    let bg: Color = rgb8(248, 248, 252);
    let mut renderer = VelloRenderer::new().expect("vello renderer init");

    // ── Render 1: colour gradient along the line ───────────────────
    {
        let (w, h) = (1200u32, 300u32);
        let n = 80;
        let xs: Vec<f64> = (0..n)
            .map(|i| 80.0 + i as f64 / (n - 1) as f64 * 1040.0)
            .collect();
        let ys: Vec<f64> = xs
            .iter()
            .enumerate()
            .map(|(i, _)| 150.0 + 60.0 * (i as f64 * 0.18).sin())
            .collect();
        let points: Vec<Point> = xs
            .iter()
            .zip(ys.iter())
            .map(|(x, y)| Point::new(*x, *y))
            .collect();
        // 5-stop gradient: cool blues to warm reds.
        let stops = [
            rgb8(60, 80, 200),
            rgb8(80, 160, 200),
            rgb8(220, 220, 220),
            rgb8(220, 130, 80),
            rgb8(200, 50, 60),
        ];
        let colors: Vec<Color> = (0..n)
            .map(|i| interpolate_stops(&stops, i as f64 / (n - 1) as f64))
            .collect();
        let opts = RibbonOptions {
            half_width: pt_to_px(12.0, dpi) * 0.5,
            cap: Cap::Round,
            join: Join::Round,
            miter_limit: 4.0,
        };
        let mesh = polyline_gradient(&points, &colors, &opts);
        render_mesh(
            &mut renderer,
            &mesh,
            w,
            h,
            dpi,
            bg,
            "examples/ribbon_1_gradient_along.png",
        );
    }

    // ── Render 2: variable width along the line ────────────────────
    {
        let (w, h) = (1200u32, 300u32);
        let n = 80;
        let xs: Vec<f64> = (0..n)
            .map(|i| 80.0 + i as f64 / (n - 1) as f64 * 1040.0)
            .collect();
        let ys: Vec<f64> = (0..n)
            .map(|i| 150.0 + 60.0 * (i as f64 * 0.18).sin())
            .collect();
        let points: Vec<Point> = xs
            .iter()
            .zip(ys.iter())
            .map(|(x, y)| Point::new(*x, *y))
            .collect();
        // Width ramps from 2pt to 20pt linearly.
        let half_widths: Vec<f64> = (0..n)
            .map(|i| {
                let t = i as f64 / (n - 1) as f64;
                pt_to_px(2.0 + (20.0 - 2.0) * t, dpi) * 0.5
            })
            .collect();
        let opts = RibbonOptions {
            half_width: 1.0,
            cap: Cap::Round,
            join: Join::Round,
            miter_limit: 4.0,
        };
        // `polyline_ribbon_full` with no colours uses black; pass a
        // same-colour slice for the desired stroke colour.
        let stroke = rgb8(40, 90, 180);
        let colors = vec![stroke; n];
        let mesh = polyline_ribbon_full(&points, Some(&colors), Some(&half_widths), &opts);
        render_mesh(
            &mut renderer,
            &mesh,
            w,
            h,
            dpi,
            bg,
            "examples/ribbon_2_variable_width.png",
        );
    }

    // ── Render 3: gradient + variable width on a self-intersecting
    // figure-8 (Lissajous 1:2). The polyline crosses itself once at
    // the centre — each crossing arm renders at a different width
    // and colour, and SrcOver compositing layers them in source order
    // (later vertices draw on top of earlier ones).
    {
        let (w, h) = (1200u32, 400u32);
        let n = 240;
        let cx = 600.0;
        let cy = 200.0;
        let amp_x = 500.0;
        let amp_y = 120.0;
        let xs: Vec<f64> = (0..n)
            .map(|i| {
                let t = i as f64 / (n - 1) as f64 * std::f64::consts::TAU;
                cx + amp_x * t.sin()
            })
            .collect();
        let ys: Vec<f64> = (0..n)
            .map(|i| {
                let t = i as f64 / (n - 1) as f64 * std::f64::consts::TAU;
                cy + amp_y * (2.0 * t).sin()
            })
            .collect();
        let points: Vec<Point> = xs
            .iter()
            .zip(ys.iter())
            .map(|(x, y)| Point::new(*x, *y))
            .collect();
        let stops = [
            rgb8(60, 80, 200),
            rgb8(80, 160, 200),
            rgb8(220, 220, 220),
            rgb8(220, 130, 80),
            rgb8(200, 50, 60),
        ];
        let colors: Vec<Color> = (0..n)
            .map(|i| interpolate_stops(&stops, i as f64 / (n - 1) as f64))
            .collect();
        let half_widths: Vec<f64> = (0..n)
            .map(|i| {
                let t = i as f64 / (n - 1) as f64;
                pt_to_px(2.0 + (24.0 - 2.0) * t, dpi) * 0.5
            })
            .collect();
        let opts = RibbonOptions {
            half_width: 1.0,
            cap: Cap::Round,
            join: Join::Round,
            miter_limit: 4.0,
        };
        let mesh = polyline_ribbon_full(&points, Some(&colors), Some(&half_widths), &opts);
        render_mesh(
            &mut renderer,
            &mesh,
            w,
            h,
            dpi,
            bg,
            "examples/ribbon_3_full.png",
        );
    }

    // ── Render 4: 3×3 cap/join grid ────────────────────────────────
    {
        let (w, h) = (900u32, 700u32);
        let caps = [
            ("butt", Cap::Butt),
            ("square", Cap::Square),
            ("round", Cap::Round),
        ];
        let joins = [
            ("miter", Join::Miter),
            ("bevel", Join::Bevel),
            ("round", Join::Round),
        ];
        // Build 9 ribbons in one mesh (or one render): for each
        // (row, col), zigzag polyline showing the cap and join.
        let mut all_meshes: Vec<Mesh> = Vec::new();
        let cell_w = w as f64 / 3.0;
        let cell_h = h as f64 / 3.0;
        for (r_idx, (_cap_name, cap)) in caps.iter().enumerate() {
            for (c_idx, (_join_name, join)) in joins.iter().enumerate() {
                let cx = c_idx as f64 * cell_w;
                let cy = r_idx as f64 * cell_h;
                // Zigzag polyline filling the cell.
                let pad = 30.0;
                let pts = vec![
                    Point::new(cx + pad, cy + cell_h - pad),
                    Point::new(cx + cell_w * 0.5, cy + pad),
                    Point::new(cx + cell_w - pad, cy + cell_h - pad),
                ];
                let opts = RibbonOptions {
                    half_width: pt_to_px(18.0, dpi) * 0.5,
                    cap: *cap,
                    join: *join,
                    miter_limit: 4.0,
                };
                let stroke = rgb8(40, 90, 180);
                all_meshes.push(polyline_ribbon(&pts, stroke, &opts));
            }
        }
        render_meshes(
            &mut renderer,
            &all_meshes,
            w,
            h,
            dpi,
            bg,
            "examples/ribbon_4_caps_joins.png",
        );
    }

    // ── Render 5: closed-loop rainbow ──────────────────────────────
    // Regular dodecagon vertices, one full hue cycle around the
    // loop. The wrap segment interpolates colors[n-1] → colors[0]
    // (≈ magenta → red, a short hop on the colour wheel), which
    // should be visually indistinguishable from the other segment
    // transitions — i.e. no seam at the close.
    {
        let (w, h) = (700u32, 700u32);
        let cx = 350.0;
        let cy = 350.0;
        let radius = 260.0;
        let n = 12;
        let points: Vec<Point> = (0..n)
            .map(|i| {
                let theta = i as f64 / n as f64 * std::f64::consts::TAU;
                Point::new(cx + radius * theta.cos(), cy + radius * theta.sin())
            })
            .collect();
        let colors: Vec<Color> = (0..n)
            .map(|i| hsv_to_color(i as f64 / n as f64, 0.85, 0.95))
            .collect();
        let opts = RibbonOptions {
            half_width: pt_to_px(28.0, dpi) * 0.5,
            cap: Cap::Butt,
            join: Join::Round,
            miter_limit: 4.0,
        };
        let mesh = polygon_gradient(&points, &colors, &opts);
        render_mesh(
            &mut renderer,
            &mesh,
            w,
            h,
            dpi,
            bg,
            "examples/ribbon_5_closed_rainbow.png",
        );
    }

    // ── Render 6: closed loop with gradient + variable width ───────
    // Five-lobed polar curve r(θ) = R + a·sin(5θ) sampled at 240
    // points. Colours cycle the full hue wheel once; widths pulse
    // at twice the lobe frequency so the ribbon visibly fattens and
    // narrows around the loop. Both pieces close seamlessly because
    // `polygon_*` treats the n samples as one continuous ring.
    {
        let (w, h) = (900u32, 900u32);
        let cx = 450.0;
        let cy = 450.0;
        let base_r = 280.0;
        let amp_r = 70.0;
        let lobes = 5.0;
        let n = 240;
        let points: Vec<Point> = (0..n)
            .map(|i| {
                let theta = i as f64 / n as f64 * std::f64::consts::TAU;
                let r = base_r + amp_r * (lobes * theta).sin();
                Point::new(cx + r * theta.cos(), cy + r * theta.sin())
            })
            .collect();
        let colors: Vec<Color> = (0..n)
            .map(|i| hsv_to_color(i as f64 / n as f64, 0.85, 0.95))
            .collect();
        let half_widths: Vec<f64> = (0..n)
            .map(|i| {
                let theta = i as f64 / n as f64 * std::f64::consts::TAU;
                // Width pulses between ~4 pt and ~22 pt.
                let pt = 13.0 + 9.0 * (2.0 * lobes * theta).sin();
                pt_to_px(pt, dpi) * 0.5
            })
            .collect();
        let opts = RibbonOptions {
            half_width: 1.0,
            cap: Cap::Butt, // ignored by polygon_*
            join: Join::Round,
            miter_limit: 4.0,
        };
        let mesh = polygon_ribbon_full(&points, Some(&colors), Some(&half_widths), &opts);
        render_mesh(
            &mut renderer,
            &mesh,
            w,
            h,
            dpi,
            bg,
            "examples/ribbon_6_closed_full.png",
        );
    }
}

pub const fn to_vec2(self) -> Vec2

Convert this point into a Vec2.

Examples found in repository

examples/shapes_demo.rs (line 41)

fn draw_shape_centered(
    scene: &mut impl SceneBuilder,
    shape: &Shape,
    center: Point,
    size: f64,
    brush: &Brush,
    stroke_world_width: f64,
) {
    let xform = Affine::translate(center.to_vec2()) * Affine::scale(size);
    let (paths, style) = match shape.kind() {
        ShapeKind::Paths { paths, style } => (paths, style),
        ShapeKind::Glyph { .. } => return,
    };
    match style {
        ShapeStyle::Fill => {
            for sub in paths {
                scene.fill(FillRule::NonZero, xform, brush, None, sub, PickId::Skip);
            }
        }
        ShapeStyle::Stroke => {
            let stroke = Stroke::new(stroke_world_width / size)
                .with_caps(Cap::Round)
                .with_join(Join::Round);
            for sub in paths {
                scene.stroke(&stroke, xform, brush, None, sub, PickId::Skip);
            }
        }
    }
}

fn draw_shape_attached(
    scene: &mut impl SceneBuilder,
    shape: &Shape,
    placement: Point,
    direction: Vec2,
    size: f64,
    brush: &Brush,
    stroke_world_width: f64,
) {
    let perp = Vec2::new(-direction.y, direction.x);
    let a = shape.anchor();
    let anchor_world = direction * (a.x * size) + perp * (a.y * size);
    let origin = placement - anchor_world;
    let xform = Affine::translate(origin.to_vec2())
        * Affine::rotate(direction.atan2())
        * Affine::scale(size);
    let (paths, style) = match shape.kind() {
        ShapeKind::Paths { paths, style } => (paths, style),
        ShapeKind::Glyph { .. } => return,
    };
    match style {
        ShapeStyle::Fill => {
            for sub in paths {
                scene.fill(FillRule::NonZero, xform, brush, None, sub, PickId::Skip);
            }
        }
        ShapeStyle::Stroke => {
            let stroke = Stroke::new(stroke_world_width / size)
                .with_caps(Cap::Round)
                .with_join(Join::Round);
            for sub in paths {
                scene.stroke(&stroke, xform, brush, None, sub, PickId::Skip);
            }
        }
    }
}

pub fn lerp(self, other: Point, t: f64) -> Point

Linearly interpolate between two points.

pub const fn midpoint(self, other: Point) -> Point

Determine the midpoint of two points.

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

Euclidean distance.

See Vec2::hypot for the same operation on Vec2.

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

Squared Euclidean distance.

See Vec2::hypot2 for the same operation on Vec2.

pub fn round(self) -> Point

Returns a new Point, with x and y rounded to the nearest integer.

Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).round();
let b = Point::new(3.0, -3.1).round();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);

pub fn ceil(self) -> Point

Returns a new Point, with x and y rounded up to the nearest integer, unless they are already an integer.

Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).ceil();
let b = Point::new(3.0, -3.1).ceil();
assert_eq!(a.x, 4.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);

pub fn floor(self) -> Point

Returns a new Point, with x and y rounded down to the nearest integer, unless they are already an integer.

Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).floor();
let b = Point::new(3.0, -3.1).floor();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 3.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -4.0);

pub fn expand(self) -> Point

Returns a new Point, with x and y rounded away from zero to the nearest integer, unless they are already an integer.

Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).expand();
let b = Point::new(3.0, -3.1).expand();
assert_eq!(a.x, 4.0);
assert_eq!(a.y, 4.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -4.0);

pub fn trunc(self) -> Point

Returns a new Point, with x and y rounded towards zero to the nearest integer, unless they are already an integer.

Examples

use kurbo::Point;
let a = Point::new(3.3, 3.6).trunc();
let b = Point::new(3.0, -3.1).trunc();
assert_eq!(a.x, 3.0);
assert_eq!(a.y, 3.0);
assert_eq!(b.x, 3.0);
assert_eq!(b.y, -3.0);

pub const fn is_finite(self) -> bool

Is this point finite?

pub const fn is_nan(self) -> bool

Is this point NaN?

pub const fn get_coord(self, axis: Axis) -> f64

Get the member matching the given axis.

pub const fn get_coord_mut(&mut self, axis: Axis) -> &mut f64

Get a mutable reference to the member matching the given axis.

pub const fn set_coord(&mut self, axis: Axis, value: f64)

Set the member matching the given axis to the given value.

Trait Implementations

impl Add<(f64, f64)> for Point

type Output = Point

The resulting type after applying the + operator.

fn add(self, _: (f64, f64)) -> Point

Performs the + operation.

impl Add<Vec2> for Point

type Output = Point

The resulting type after applying the + operator.

fn add(self, other: Vec2) -> Point

Performs the + operation.

impl AddAssign<(f64, f64)> for Point

fn add_assign(&mut self, _: (f64, f64))

Performs the += operation.

impl AddAssign<Vec2> for Point

fn add_assign(&mut self, other: Vec2)

Performs the += operation.

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 Copy for Point

impl Debug for Point

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

Formats the value using the given formatter.

impl Default for Point

fn default() -> Point

Returns the “default value” for a type.

impl Display for Point

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

Formats the value using the given formatter.

impl From<(f32, f32)> for Point

fn from(v: (f32, f32)) -> Point

Converts to this type from the input type.

impl From<(f64, f64)> for Point

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

Converts to this type from the input type.

impl Mul<Point> for Affine

type Output = Point

The resulting type after applying the * operator.

fn mul(self, other: Point) -> Point

Performs the * operation.

impl PartialEq for Point

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Point

impl Sub for Point

type Output = Vec2

The resulting type after applying the - operator.

fn sub(self, other: Point) -> Vec2

Performs the - operation.

impl Sub<(f64, f64)> for Point

type Output = Point

The resulting type after applying the - operator.

fn sub(self, _: (f64, f64)) -> Point

Performs the - operation.

impl Sub<Vec2> for Point

type Output = Point

The resulting type after applying the - operator.

fn sub(self, other: Vec2) -> Point

Performs the - operation.

impl SubAssign<(f64, f64)> for Point

fn sub_assign(&mut self, _: (f64, f64))

Performs the -= operation.

impl SubAssign<Vec2> for Point

fn sub_assign(&mut self, other: Vec2)

Performs the -= operation.