Axis-aware coordinate helpers on Point, Vec2, Size, and Rect

Author: waywardmonkeys

CHANGELOG.md

@@ -15,6 +15,10 @@ You can find its changes [documented below](#0131-2026-05-13).
 
 This release has an [MSRV][] of 1.85.
 
+## Added
+
+- Axis-aware coordinate helpers on `Point`, `Vec2`, `Size`, and `Rect`. ([#592][] by [@waywardmonkeys][])
+
 ## [0.13.1][] (2026-05-13)
 
 This release has an [MSRV][] of 1.85.
@@ -313,6 +317,7 @@ Note: A changelog was not kept for or before this release
 [#575]: https://github.com/linebender/kurbo/pull/575
 [#580]: https://github.com/linebender/kurbo/pull/580
 [#585]: https://github.com/linebender/kurbo/pull/585
+[#592]: https://github.com/linebender/kurbo/pull/592
 
 [Unreleased]: https://github.com/linebender/kurbo/compare/v0.13.1...HEAD
 [0.13.1]: https://github.com/linebender/kurbo/releases/tag/v0.13.1

kurbo/src/point.rs

@@ -229,6 +229,25 @@ impl Point {
             Axis::Vertical => self.y = value,
         }
     }
+
+    /// Return a new `Point` with the member matching the given axis set to
+    /// the given value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kurbo::{Axis, Point};
+    ///
+    /// let point = Point::new(2.0, 3.0).with_coord(Axis::Vertical, 5.0);
+    /// assert_eq!(point, Point::new(2.0, 5.0));
+    /// ```
+    #[inline]
+    pub const fn with_coord(self, axis: Axis, value: f64) -> Point {
+        match axis {
+            Axis::Horizontal => Point::new(value, self.y),
+            Axis::Vertical => Point::new(self.x, value),
+        }
+    }
 }
 
 impl From<(f32, f32)> for Point {

kurbo/src/rect.rs

@@ -641,6 +641,93 @@ impl Rect {
         self.x0.is_nan() || self.y0.is_nan() || self.x1.is_nan() || self.y1.is_nan()
     }
 
+    /// Return the extent of this rectangle on the given axis.
+    ///
+    /// This is equivalent to [`Rect::width`] for [`Axis::Horizontal`] and
+    /// [`Rect::height`] for [`Axis::Vertical`].
+    ///
+    /// Note: nothing forbids negative width or height.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kurbo::{Axis, Rect};
+    ///
+    /// let rect = Rect::new(1.0, 2.0, 4.0, 7.0);
+    /// assert_eq!(rect.extent(Axis::Horizontal), 3.0);
+    /// assert_eq!(rect.extent(Axis::Vertical), 5.0);
+    /// ```
+    #[inline]
+    pub const fn extent(&self, axis: Axis) -> f64 {
+        match axis {
+            Axis::Horizontal => self.width(),
+            Axis::Vertical => self.height(),
+        }
+    }
+
+    /// Return the minimum coordinate on the given axis.
+    ///
+    /// This returns the lesser endpoint even if this rectangle has negative
+    /// width or height.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kurbo::{Axis, Rect};
+    ///
+    /// let rect = Rect::new(8.0, 2.0, 4.0, 7.0);
+    /// assert_eq!(rect.min_coord(Axis::Horizontal), 4.0);
+    /// assert_eq!(rect.min_coord(Axis::Vertical), 2.0);
+    /// ```
+    #[inline]
+    pub const fn min_coord(&self, axis: Axis) -> f64 {
+        match axis {
+            Axis::Horizontal => self.min_x(),
+            Axis::Vertical => self.min_y(),
+        }
+    }
+
+    /// Return the maximum coordinate on the given axis.
+    ///
+    /// This returns the greater endpoint even if this rectangle has negative
+    /// width or height.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kurbo::{Axis, Rect};
+    ///
+    /// let rect = Rect::new(8.0, 2.0, 4.0, 7.0);
+    /// assert_eq!(rect.max_coord(Axis::Horizontal), 8.0);
+    /// assert_eq!(rect.max_coord(Axis::Vertical), 7.0);
+    /// ```
+    #[inline]
+    pub const fn max_coord(&self, axis: Axis) -> f64 {
+        match axis {
+            Axis::Horizontal => self.max_x(),
+            Axis::Vertical => self.max_y(),
+        }
+    }
+
+    /// Return the center coordinate on the given axis.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kurbo::{Axis, Rect};
+    ///
+    /// let rect = Rect::new(1.0, 2.0, 4.0, 8.0);
+    /// assert_eq!(rect.center_coord(Axis::Horizontal), 2.5);
+    /// assert_eq!(rect.center_coord(Axis::Vertical), 5.0);
+    /// ```
+    #[inline]
+    pub const fn center_coord(&self, axis: Axis) -> f64 {
+        match axis {
+            Axis::Horizontal => 0.5 * (self.x0 + self.x1),
+            Axis::Vertical => 0.5 * (self.y0 + self.y1),
+        }
+    }
+
     /// Get the members matching the given axis.
     #[inline]
     pub const fn get_coords(self, axis: Axis) -> (f64, f64) {
@@ -667,6 +754,32 @@ impl Rect {
             Axis::Vertical => (self.y0, self.y1) = (v0, v1),
         }
     }
+
+    /// Return a new `Rect` with the members matching the given axis set to
+    /// the given values.
+    ///
+    /// This sets the raw endpoints for the axis and does not reorder or
+    /// normalize them.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kurbo::{Axis, Rect};
+    ///
+    /// let rect = Rect::new(1.0, 2.0, 4.0, 7.0).with_coords(
+    ///     Axis::Horizontal,
+    ///     10.0,
+    ///     3.0,
+    /// );
+    /// assert_eq!(rect, Rect::new(10.0, 2.0, 3.0, 7.0));
+    /// ```
+    #[inline]
+    pub const fn with_coords(self, axis: Axis, v0: f64, v1: f64) -> Rect {
+        match axis {
+            Axis::Horizontal => Rect::new(v0, self.y0, v1, self.y1),
+            Axis::Vertical => Rect::new(self.x0, v0, self.x1, v1),
+        }
+    }
 }
 
 impl From<(Point, Point)> for Rect {

kurbo/src/size.rs

@@ -333,6 +333,25 @@ impl Size {
             Axis::Vertical => self.height = value,
         }
     }
+
+    /// Return a new `Size` with the member matching the given axis set to
+    /// the given value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kurbo::{Axis, Size};
+    ///
+    /// let size = Size::new(2.0, 3.0).with_coord(Axis::Vertical, 5.0);
+    /// assert_eq!(size, Size::new(2.0, 5.0));
+    /// ```
+    #[inline]
+    pub const fn with_coord(self, axis: Axis, value: f64) -> Size {
+        match axis {
+            Axis::Horizontal => Size::new(value, self.height),
+            Axis::Vertical => Size::new(self.width, value),
+        }
+    }
 }
 
 impl fmt::Debug for Size {

kurbo/src/vec2.rs

@@ -371,6 +371,25 @@ impl Vec2 {
             Axis::Vertical => self.y = value,
         }
     }
+
+    /// Return a new `Vec2` with the member matching the given axis set to
+    /// the given value.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use kurbo::{Axis, Vec2};
+    ///
+    /// let vec = Vec2::new(2.0, 3.0).with_coord(Axis::Horizontal, 5.0);
+    /// assert_eq!(vec, Vec2::new(5.0, 3.0));
+    /// ```
+    #[inline]
+    pub const fn with_coord(self, axis: Axis, value: f64) -> Vec2 {
+        match axis {
+            Axis::Horizontal => Vec2::new(value, self.y),
+            Axis::Vertical => Vec2::new(self.x, value),
+        }
+    }
 }
 
 impl From<(f64, f64)> for Vec2 {