feat: create Scalable3D protocol; conform Size3D, AffineTransform3D and Vecto3D with Scalable3D protocol

Author: helbertgomes

Sources/OpenSpatial/3D primitives/Size3D.swift

@@ -248,4 +248,31 @@ extension Size3D : Primitive3D {
     public func applying(_ transform: AffineTransform3D) -> Size3D {
         fatalError("Size3D does not support applying affine transforms.")
     }
+}
+
+extension Size3D : Scalable3D {
+
+    /// Returns a new entity scaled by the specified size.
+    /// 
+    /// - Parameter size: A size that contains the scale factors for each axis.
+    /// - Returns: A new scaled entity.
+    /// - Complexity: O(1)
+    @inline(__always)
+    public func scaled(by size: Size3D) -> Size3D {
+        .init(width: self.width * size.width,
+              height: self.height * size.height,
+              depth: self.depth * size.depth)
+    }
+
+    /// Returns a new entity scaled uniformly by the specified factor.
+    /// 
+    /// - Parameter scale: A double-precision value that specifies the uniform scale factor.
+    /// - Returns: A new scaled entity.
+    /// - Complexity: O(1)
+    @inline(__always)
+    public func uniformlyScaled(by scale: Double) -> Size3D {
+        .init(width: self.width * scale,
+              height: self.height * scale,
+              depth: self.depth * scale)
+    }
 }

Sources/OpenSpatial/Affine and projective transforms/AffineTransform3D.swift

@@ -90,4 +90,33 @@ extension AffineTransform3D {
     public static func *= (lhs: inout AffineTransform3D, rhs: AffineTransform3D) {
         lhs = lhs * rhs
     }
+}
+
+extension AffineTransform3D : Scalable3D {
+
+    // MARK: - Scaling transforms
+
+    /// Returns a new affine transform scaled by the specified size.
+    /// 
+    /// - Parameter size: A size that contains the scale factors for each axis.
+    /// - Returns: A new scaled affine transform.
+    /// - Complexity: O(1)
+    @inline(__always)
+    public func scaled(by size: Size3D) -> AffineTransform3D {
+        var scaleTransform = AffineTransform3D()
+        scaleTransform[0, 0] = size.width
+        scaleTransform[1, 1] = size.height
+        scaleTransform[2, 2] = size.depth
+        return self * scaleTransform
+    }
+
+    /// Returns a new entity scaled uniformly by the specified factor.
+    /// 
+    /// - Parameter scale: A double-precision value that specifies the uniform scale factor.
+    /// - Returns: A new scaled entity.
+    /// - Complexity: O(1)
+    @inline(__always)
+    public func uniformlyScaled(by scale: Double) -> AffineTransform3D {
+        self.scaled(by: Size3D(width: scale, height: scale, depth: scale))
+    }
 }

Sources/OpenSpatial/Data structures/Vector3D.swift

@@ -315,4 +315,29 @@ extension Vector3D : Primitive3D {
         let newZ = x * transform.matrix[0][2] + y * transform.matrix[1][2] + z * transform.matrix[2][2] + transform.matrix[3][2]
         return Vector3D(x: newX, y: newY, z: newZ)
     }
+}
+
+extension Vector3D : Scalable3D {
+
+    // MARK: - Instance methods
+
+    /// Returns a new entity scaled by the specified size.
+    /// 
+    /// - Parameter size: A size that contains the scale factors for each axis.
+    /// - Returns: A new scaled entity.
+    /// - Complexity: O(1)
+    @inline(__always)
+    public func scaled(by size: Size3D) -> Vector3D {
+        .init(x: x * size.width, y: y * size.height, z: z * size.depth)
+    }
+
+    /// Returns a new entity scaled uniformly by the specified factor.
+    /// 
+    /// - Parameter scale: A double-precision value that specifies the uniform scale factor.
+    /// - Returns: A new scaled entity.
+    /// - Complexity: O(1)
+    @inline(__always)
+    public func uniformlyScaled(by scale: Double) -> Vector3D {
+        .init(x: x * scale, y: y * scale, z: z * scale)
+    }
 }

Sources/OpenSpatial/Protocols/Scalable3D.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+/// A protocol that defines scalable 3D types.
+public protocol Scalable3D {
+
+    // MARK: - Instance methods
+
+    /// Scales the entity by the specified size.
+    /// 
+    /// - Parameter size: A size that contains the scale factors for each axis.
+    mutating func scale(by size: Size3D)
+
+    /// Scales the entity by the specified factors.
+    /// 
+    /// - Parameters:
+    ///   - x: A double-precision value that specifies the scale factor for the x-axis.
+    ///   - y: A double-precision value that specifies the scale factor for the y-axis.
+    ///   - z: A double-precision value that specifies the scale factor for the z-axis.
+    mutating func scaleBy(x: Double, y: Double, z: Double)
+
+    /// Returns a new entity scaled by the specified size.
+    /// 
+    /// - Parameter size: A size that contains the scale factors for each axis.
+    /// - Returns: A new scaled entity.
+    func scaled(by size: Size3D) -> Self
+
+    /// Scales the entity uniformly by the specified factor.
+    /// 
+    /// - Parameter scale: A double-precision value that specifies the uniform scale factor.
+    mutating func uniformlyScale(by scale: Double)
+
+    /// Returns a new entity scaled uniformly by the specified factor.
+    /// 
+    /// - Parameter scale: A double-precision value that specifies the uniform scale factor.
+    /// - Returns: A new scaled entity.
+    func uniformlyScaled(by scale: Double) -> Self
+}
+
+extension Scalable3D {
+
+    /// Scales the entity by the specified size.
+    /// 
+    /// - Parameter size: A size that contains the scale factors for each axis.
+    public mutating func scale(by size: Size3D) {
+        self = self.scaled(by: size)
+    }
+
+    /// Scales the entity by the specified factors.
+    /// 
+    /// - Parameters:
+    ///   - x: A double-precision value that specifies the scale factor for the x-axis.
+    ///   - y: A double-precision value that specifies the scale factor for the y-axis.
+    ///   - z: A double-precision value that specifies the scale factor for the z-axis.
+    public mutating func scaleBy(x: Double, y: Double, z: Double) {
+        self.scale(by: Size3D(width: x, height: y, depth: z))
+    }
+
+    /// Scales the entity uniformly by the specified factor.
+    /// 
+    /// - Parameter scale: A double-precision value that specifies the uniform scale factor.
+    public mutating func uniformlyScale(by scale: Double) {
+        self.scale(by: Size3D(width: scale, height: scale, depth: scale))
+    }
+}

Tests/OpenSpatialTests/3D primitives/Size3DTests.swift

@@ -169,4 +169,22 @@ struct Size3DTests {
         #expect(infinitySize.height == Double.infinity)
         #expect(infinitySize.depth == Double.infinity)
     }
+
+    // MARK: - Scalable3D tests
+
+    @Test func testScaledBy() {
+        let size = Size3D(width: 2.0, height: 3.0, depth: 4.0)
+        let scaledSize = size.scaled(by: .init(width: 3, height: 3, depth: 3))
+        #expect(scaledSize.width == 6.0)
+        #expect(scaledSize.height == 9.0)
+        #expect(scaledSize.depth == 12.0)
+    }
+
+    @Test func testUniformScale() {
+        let size = Size3D(width: 2.0, height: 3.0, depth: 4.0)
+        let uniformScaledSize = size.uniformlyScaled(by: 2.0)
+        #expect(uniformScaledSize.width == 4.0)
+        #expect(uniformScaledSize.height == 6.0)
+        #expect(uniformScaledSize.depth == 8.0)
+    }
 }

Tests/OpenSpatialTests/Affine and projective transforms/AffineTransform3DTests.swift

@@ -51,4 +51,30 @@ struct AffineTransform3DTests {
         ]
         #expect(result.matrix == expectedMatrix)
     }
+
+    // MARK: - Scalable3D tests
+
+    @Test func testScalingAffineTransform3D() {
+        var transform = AffineTransform3D()
+        transform.scaleBy(x: 2.0, y: 3.0, z: 4.0)
+        let expectedMatrix: [[Double]] = [
+            [2.0, 0.0, 0.0, 0.0],
+            [0.0, 3.0, 0.0, 0.0],
+            [0.0, 0.0, 4.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0]
+        ]
+        #expect(transform.matrix == expectedMatrix)
+    }
+
+    @Test func testUniformScalingAffineTransform3D() {
+        var transform = AffineTransform3D()
+        transform.uniformlyScale(by: 5.0)
+        let expectedMatrix: [[Double]] = [
+            [5.0, 0.0, 0.0, 0.0],
+            [0.0, 5.0, 0.0, 0.0],
+            [0.0, 0.0, 5.0, 0.0],
+            [0.0, 0.0, 0.0, 1.0]
+        ]
+        #expect(transform.matrix == expectedMatrix)
+    }
 }

Tests/OpenSpatialTests/Data structures/Vector3DTests.swift

@@ -228,4 +228,18 @@ struct Vector3DTests {
         let transformedVector = vector.applying(transform)
         #expect(transformedVector == Vector3D(x: 10.0, y: 40.0, z: 90.0))
     }
+
+    // MARK: - Scalable3D tests
+
+    @Test func testScalingVector3D() {
+        var vector = Vector3D(x: 1.0, y: 2.0, z: 3.0)
+        vector.scaleBy(x: 2.0, y: 3.0, z: 4.0)
+        #expect(vector == Vector3D(x: 2.0, y: 6.0, z: 12.0))
+    }
+
+    @Test func testUniformScalingVector3D() {
+        var vector = Vector3D(x: 1.0, y: 2.0, z: 3.0)
+        vector.uniformlyScale(by: 3.0)
+        #expect(vector == Vector3D(x: 3.0, y: 6.0, z: 9.0))
+    }
 }