Add generic resizing method for scaling geometry ranges

Add resizing(_:in:to:alignment:) that scales a range of geometry along
an axis to a new length. Unlike extending (which extrudes at a point),
this method scales an existing region and can both stretch and compress.

- Add generic resizing method to Geometry protocol (works for 2D and 3D)
- Add box(size:at:) factory to Dimensionality protocol for generic masks
- Add generic mask property to BoundingBox using the new factory
- Add within(_:along:) convenience methods for single-axis clipping
- Add tests for bounds and volume preservation

Author: tomasf

Sources/Cadova/Abstract Layer/Operations/Bounds/Extend.swift

@@ -1,5 +1,80 @@
 import Foundation
 
+public extension Geometry {
+    /// Resizes a region of the geometry along an axis by scaling it to a new length.
+    ///
+    /// This method scales the geometry within a specified range to a target length,
+    /// while keeping geometry outside the range intact (translated to accommodate the change).
+    ///
+    /// - Parameters:
+    ///   - axis: The axis along which to resize.
+    ///   - range: The range of the geometry to scale.
+    ///   - newLength: The target length for the range. Must be non-negative.
+    ///   - alignment: Which side stays fixed: `.min` (default), `.max`, or `.mid`.
+    ///
+    /// ## Examples
+    /// ```swift
+    /// // Compress the middle section of a rectangle
+    /// Rectangle(x: 30, y: 10)
+    ///     .resizing(.x, in: 10...20, to: 5)
+    ///
+    /// // Compress the middle section of a cylinder
+    /// Cylinder(diameter: 20, height: 30)
+    ///     .resizing(.z, in: 10...20, to: 5)
+    ///
+    /// // Stretch a section while keeping the top fixed
+    /// box.resizing(.z, in: 5...15, to: 20, alignment: .max)
+    /// ```
+    ///
+    @GeometryBuilder<D>
+    func resizing(
+        _ axis: D.Axis,
+        in range: ClosedRange<Double>,
+        to newLength: Double,
+        alignment: AxisAlignment = .min
+    ) -> D.Geometry {
+        let originalLength = range.upperBound - range.lowerBound
+        precondition(newLength >= 0, "New length must be non-negative")
+        precondition(originalLength > 0, "Range must have positive length")
+
+        let delta = newLength - originalLength
+        let scale = newLength / originalLength
+
+        // The point that remains fixed based on alignment
+        let fixedPoint = range.lowerBound + originalLength * alignment.fraction
+
+        // Translation amounts for sections outside the range
+        let lowerTranslation = -delta * alignment.fraction
+        let upperTranslation = delta * (1 - alignment.fraction)
+
+        let axisVector = D.Direction(axis, .positive).unitVector
+
+        measuringBounds { body, bounds in
+            // Geometry below the range
+            body.intersecting {
+                bounds.partialBox(from: nil, to: range.lowerBound, in: axis, margin: 1).mask
+            }
+            .translated(axisVector * lowerTranslation)
+
+            // Geometry within the range - scale around the fixed point
+            if scale > 0 {
+                body.intersecting {
+                    bounds.partialBox(from: range.lowerBound, to: range.upperBound, in: axis, margin: 1).mask
+                }
+                .translated(axisVector * -fixedPoint)
+                .scaled(D.Vector(1).with(axis, as: scale))
+                .translated(axisVector * fixedPoint)
+            }
+
+            // Geometry above the range
+            body.intersecting {
+                bounds.partialBox(from: range.upperBound, to: nil, in: axis, margin: 1).mask
+            }
+            .translated(axisVector * upperTranslation)
+        }
+    }
+}
+
 public extension Geometry3D {
     /// Lengthens the geometry by a given amount at the specified plane.
     ///

Sources/Cadova/Abstract Layer/Operations/Within.swift

@@ -3,6 +3,30 @@ import Foundation
 public typealias WithinRange = RangeExpression<Double> & Sendable
 
 public extension Geometry2D {
+    /// Returns a geometry clipped to the specified range along an axis.
+    ///
+    /// This is a convenience method equivalent to calling `within(x:y:)` with
+    /// only one axis specified.
+    ///
+    /// - Parameters:
+    ///   - range: The range to clip to.
+    ///   - axis: The axis along which to clip.
+    /// - Returns: A geometry clipped to the specified range.
+    ///
+    /// ## Example
+    /// ```swift
+    /// // Keep only the right half of a circle
+    /// Circle(diameter: 10)
+    ///     .within(0..., along: .x)
+    /// ```
+    ///
+    func within(_ range: some WithinRange, along axis: Axis2D) -> any Geometry2D {
+        switch axis {
+        case .x: within(x: range)
+        case .y: within(y: range)
+        }
+    }
+
     /// Returns a geometry that is clipped within the specified ranges along the x and y axes.
     ///
     /// This method is useful for trimming a geometry to a specific region of space. Axes that are `nil` are left unbounded. You can use
@@ -31,6 +55,31 @@ public extension Geometry2D {
 }
 
 public extension Geometry3D {
+    /// Returns a geometry clipped to the specified range along an axis.
+    ///
+    /// This is a convenience method equivalent to calling `within(x:y:z:)` with
+    /// only one axis specified.
+    ///
+    /// - Parameters:
+    ///   - range: The range to clip to.
+    ///   - axis: The axis along which to clip.
+    /// - Returns: A geometry clipped to the specified range.
+    ///
+    /// ## Example
+    /// ```swift
+    /// // Keep only the top half of a sphere
+    /// Sphere(diameter: 10)
+    ///     .within(0..., along: .z)
+    /// ```
+    ///
+    func within(_ range: some WithinRange, along axis: Axis3D) -> any Geometry3D {
+        switch axis {
+        case .x: within(x: range)
+        case .y: within(y: range)
+        case .z: within(z: range)
+        }
+    }
+
     /// Returns a geometry that is clipped within the specified ranges along the x, y, and z axes.
     ///
     /// This method is useful for trimming a 3D geometry to a specific region of space. Axes that are `nil` are left unbounded. You can use

Sources/Cadova/Dimensionality.swift

@@ -24,6 +24,8 @@ public protocol Dimensionality: SendableMetatype {
     typealias BuildResult = Cadova.BuildResult<Self>
     typealias Measurements = Cadova.Measurements<Self>
     typealias BoundingBox = Cadova.BoundingBox<Self>
+
+    static func box(size: Vector, at origin: Vector) -> Geometry
 }
 
 internal extension Dimensionality {
@@ -44,6 +46,10 @@ public struct D2: Dimensionality {
     public typealias Transform = Transform2D
     public typealias Axis = Axis2D
 
+    public static func box(size: Vector2D, at origin: Vector2D) -> any Geometry2D {
+        Rectangle(size).translated(origin)
+    }
+
     private init() {}
 }
 
@@ -60,5 +66,9 @@ public struct D3: Dimensionality {
     public typealias Transform = Transform3D
     public typealias Axis = Axis3D
 
+    public static func box(size: Vector3D, at origin: Vector3D) -> any Geometry3D {
+        Box(size).translated(origin)
+    }
+
     private init() {}
 }

Sources/Cadova/Values/BoundingBox.swift

@@ -175,13 +175,17 @@ extension BoundingBox3D {
     }
 }
 
-fileprivate extension BoundingBox {
+internal extension BoundingBox {
     func partialBox(from: Double?, to: Double?, in axis: D.Axis, margin: Double) -> BoundingBox {
         BoundingBox(
             minimum: minimum.with(axis, as: from ?? minimum[axis] - margin),
             maximum: maximum.with(axis, as: to ?? maximum[axis] + margin)
         )
     }
+
+    var mask: D.Geometry {
+        D.box(size: size, at: minimum)
+    }
 }
 
 internal extension BoundingBox2D {
@@ -190,10 +194,6 @@ internal extension BoundingBox2D {
             .partialBox(from: x?.min, to: x?.max, in: .x, margin: margin)
             .partialBox(from: y?.min, to: y?.max, in: .y, margin: margin)
     }
-
-    var mask: any Geometry2D {
-        Rectangle(size).translated(minimum)
-    }
 }
 
 internal extension BoundingBox3D {
@@ -203,8 +203,5 @@ internal extension BoundingBox3D {
             .partialBox(from: y?.min, to: y?.max, in: .y, margin: margin)
             .partialBox(from: z?.min, to: z?.max, in: .z, margin: margin)
     }
-
-    var mask: any Geometry3D {
-        Box(size).translated(minimum)
-    }
 }
+