Merge pull request #1489 from compas-dev/copilot/fix-sphere-scaled-method

Fix broken behavior with Sphere.scaled(), Cylinder.scaled(), and Capsule.scaled() and add scale() for Cone and Torus

Author: gonzalocasas

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Updated minimum library version to `2.14.1` in Rhino8 GH components.
 * Changed name of YAK package from `bluejay` to `compas`.
+* Fixed broken `scaled()` method in `Sphere`, `Cylinder`, and `Capsule` classes by overriding to accept uniform scaling factor.
 
 ### Removed
 

src/compas/geometry/shapes/cone.py

@@ -300,6 +300,22 @@ def to_brep(self):
     # Transformations
     # ==========================================================================
 
+    def scale(self, factor):
+        """Scale the cone by multiplying the radius and height by a factor.
+
+        Parameters
+        ----------
+        factor : float
+            The scaling factor.
+
+        Returns
+        -------
+        None
+
+        """
+        self.radius *= factor
+        self.height *= factor
+
     # ==========================================================================
     # Methods
     # ==========================================================================

src/compas/geometry/shapes/shape.py

@@ -432,13 +432,36 @@ def scale(self, scale):
 
         See Also
         --------
+        scaled
         translate
         rotate
         transform
 
         """
         raise NotImplementedError
 
+    def scaled(self, factor):
+        """Returns a scaled copy of the shape.
+
+        Parameters
+        ----------
+        factor : float
+            The scaling factor.
+
+        Returns
+        -------
+        :class:`compas.geometry.Shape`
+            The scaled shape.
+
+        See Also
+        --------
+        scale
+
+        """
+        shape = self.copy()
+        shape.scale(factor)
+        return shape
+
     # =============================================================================
     # Methods
     # =============================================================================

src/compas/geometry/shapes/torus.py

@@ -278,3 +278,20 @@ def transform(self, transformation):
 
         """
         self.frame.transform(transformation)
+
+    def scale(self, factor):
+        """Scale the torus by multiplying the axis radius and pipe radius by a factor.
+
+        Parameters
+        ----------
+        factor : float
+            The scaling factor.
+
+        Returns
+        -------
+        None
+
+        """
+        self.radius_axis *= factor
+        self.radius_pipe *= factor
+

tests/compas/geometry/test_capsule.py

@@ -14,3 +14,39 @@ def test_capsule_discretization(capsule):
     assert capsule.edges
     assert capsule.faces
     assert capsule.vertices
+
+
+def test_capsule_scaled():
+    """Test that Capsule.scaled() returns a scaled copy without modifying the original."""
+    capsule = Capsule(radius=5.0, height=10.0)
+    
+    # Test uniform scaling
+    scaled_capsule = capsule.scaled(0.5)
+    
+    # Original should be unchanged
+    assert capsule.radius == 5.0
+    assert capsule.height == 10.0
+    
+    # Scaled copy should have scaled dimensions
+    assert scaled_capsule.radius == 2.5
+    assert scaled_capsule.height == 5.0
+    
+    # Test scaling with factor > 1
+    scaled_capsule_2 = capsule.scaled(2.0)
+    assert scaled_capsule_2.radius == 10.0
+    assert scaled_capsule_2.height == 20.0
+    assert capsule.radius == 5.0  # Original still unchanged
+    assert capsule.height == 10.0
+
+
+def test_capsule_scale():
+    """Test that Capsule.scale() modifies the capsule in place."""
+    capsule = Capsule(radius=5.0, height=10.0)
+    
+    # Test uniform scaling
+    capsule.scale(0.5)
+    
+    # Capsule should be modified
+    assert capsule.radius == 2.5
+    assert capsule.height == 5.0
+

tests/compas/geometry/test_cone.py

@@ -14,3 +14,39 @@ def test_cone_discretization(cone):
     assert cone.edges
     assert cone.faces
     assert cone.vertices
+
+
+def test_cone_scaled():
+    """Test that Cone.scaled() returns a scaled copy without modifying the original."""
+    cone = Cone(radius=5.0, height=10.0)
+    
+    # Test uniform scaling
+    scaled_cone = cone.scaled(0.5)
+    
+    # Original should be unchanged
+    assert cone.radius == 5.0
+    assert cone.height == 10.0
+    
+    # Scaled copy should have scaled dimensions
+    assert scaled_cone.radius == 2.5
+    assert scaled_cone.height == 5.0
+    
+    # Test scaling with factor > 1
+    scaled_cone_2 = cone.scaled(2.0)
+    assert scaled_cone_2.radius == 10.0
+    assert scaled_cone_2.height == 20.0
+    assert cone.radius == 5.0  # Original still unchanged
+    assert cone.height == 10.0
+
+
+def test_cone_scale():
+    """Test that Cone.scale() modifies the cone in place."""
+    cone = Cone(radius=5.0, height=10.0)
+    
+    # Test uniform scaling
+    cone.scale(0.5)
+    
+    # Cone should be modified
+    assert cone.radius == 2.5
+    assert cone.height == 5.0
+

tests/compas/geometry/test_cylinder.py

@@ -13,3 +13,39 @@ def test_cylinder_discretization(cylinder):
     assert cylinder.edges
     assert cylinder.faces
     assert cylinder.vertices
+
+
+def test_cylinder_scaled():
+    """Test that Cylinder.scaled() returns a scaled copy without modifying the original."""
+    cylinder = Cylinder(radius=5.0, height=10.0)
+    
+    # Test uniform scaling
+    scaled_cylinder = cylinder.scaled(0.5)
+    
+    # Original should be unchanged
+    assert cylinder.radius == 5.0
+    assert cylinder.height == 10.0
+    
+    # Scaled copy should have scaled dimensions
+    assert scaled_cylinder.radius == 2.5
+    assert scaled_cylinder.height == 5.0
+    
+    # Test scaling with factor > 1
+    scaled_cylinder_2 = cylinder.scaled(2.0)
+    assert scaled_cylinder_2.radius == 10.0
+    assert scaled_cylinder_2.height == 20.0
+    assert cylinder.radius == 5.0  # Original still unchanged
+    assert cylinder.height == 10.0
+
+
+def test_cylinder_scale():
+    """Test that Cylinder.scale() modifies the cylinder in place."""
+    cylinder = Cylinder(radius=5.0, height=10.0)
+    
+    # Test uniform scaling
+    cylinder.scale(0.5)
+    
+    # Cylinder should be modified
+    assert cylinder.radius == 2.5
+    assert cylinder.height == 5.0
+

tests/compas/geometry/test_shpere.py

@@ -17,3 +17,34 @@ def test_sphere_discretization(sphere):
     assert len(sphere.edges) == expected_edge_count
     assert len(sphere.faces) == expected_face_count
     assert len(sphere.vertices) == expected_vertex_count
+
+
+def test_sphere_scaled():
+    """Test that Sphere.scaled() returns a scaled copy without modifying the original."""
+    sphere = Sphere(radius=10.0)
+    
+    # Test uniform scaling
+    scaled_sphere = sphere.scaled(0.5)
+    
+    # Original should be unchanged
+    assert sphere.radius == 10.0
+    
+    # Scaled copy should have scaled radius
+    assert scaled_sphere.radius == 5.0
+    
+    # Test scaling with factor > 1
+    scaled_sphere_2 = sphere.scaled(2.0)
+    assert scaled_sphere_2.radius == 20.0
+    assert sphere.radius == 10.0  # Original still unchanged
+
+
+def test_sphere_scale():
+    """Test that Sphere.scale() modifies the sphere in place."""
+    sphere = Sphere(radius=10.0)
+    
+    # Test uniform scaling
+    sphere.scale(0.5)
+    
+    # Sphere should be modified
+    assert sphere.radius == 5.0
+

tests/compas/geometry/test_torus.py

@@ -0,0 +1,51 @@
+import pytest
+
+from compas.geometry import Torus
+
+
+@pytest.fixture
+def torus():
+    return Torus(radius_axis=10.0, radius_pipe=2.0)
+
+
+def test_torus_discretization(torus):
+    # just checking these don't break. Could not quickly find a formula that worked to test the actual values
+    # as function of the resolution
+    assert torus.edges
+    assert torus.faces
+    assert torus.vertices
+
+
+def test_torus_scaled():
+    """Test that Torus.scaled() returns a scaled copy without modifying the original."""
+    torus = Torus(radius_axis=10.0, radius_pipe=2.0)
+    
+    # Test uniform scaling
+    scaled_torus = torus.scaled(0.5)
+    
+    # Original should be unchanged
+    assert torus.radius_axis == 10.0
+    assert torus.radius_pipe == 2.0
+    
+    # Scaled copy should have scaled dimensions
+    assert scaled_torus.radius_axis == 5.0
+    assert scaled_torus.radius_pipe == 1.0
+    
+    # Test scaling with factor > 1
+    scaled_torus_2 = torus.scaled(2.0)
+    assert scaled_torus_2.radius_axis == 20.0
+    assert scaled_torus_2.radius_pipe == 4.0
+    assert torus.radius_axis == 10.0  # Original still unchanged
+    assert torus.radius_pipe == 2.0
+
+
+def test_torus_scale():
+    """Test that Torus.scale() modifies the torus in place."""
+    torus = Torus(radius_axis=10.0, radius_pipe=2.0)
+    
+    # Test uniform scaling
+    torus.scale(0.5)
+    
+    # Torus should be modified
+    assert torus.radius_axis == 5.0
+    assert torus.radius_pipe == 1.0