Fix deprecation warnings across codebase (#588)

Replace deprecated function calls with their modern equivalents:
- rpy_angle() → matrix2ypr()/matrix2rpy() in tests and core modules
- matrix_log()/matrix_exponent() → rotation_matrix_to_axis_angle_vector()/axis_angle_vector_to_rotation_matrix()
- midrot() → interpolate_rotation_matrices()
- outer_product_matrix() → skew_symmetric_matrix()
- obj2sdf() → mesh2sdf()
- icosphere color parameter → face_colors parameter

All tests now pass without deprecation warnings.

Author: iory

skrobot/model/primitives.py

@@ -238,7 +238,7 @@ def __init__(self, radius, subdivisions=3, color=None,
         mesh = trimesh.creation.icosphere(
             radius=radius,
             subdivisions=subdivisions,
-            color=color,
+            face_colors=color,
         )
         super(Sphere, self).__init__(pos=pos, rot=rot, name=name,
                                      collision_mesh=mesh,

skrobot/model/robot_model.py

@@ -21,9 +21,9 @@
 from skrobot.coordinates import midpoint
 from skrobot.coordinates import normalize_vector
 from skrobot.coordinates import orient_coords_to_axis
-from skrobot.coordinates import rpy_angle
 from skrobot.coordinates.math import jacobian_inverse
 from skrobot.coordinates.math import matrix2quaternion
+from skrobot.coordinates.math import matrix2ypr
 from skrobot.coordinates.math import quaternion2matrix
 from skrobot.coordinates.math import quaternion2rpy
 from skrobot.coordinates.math import quaternion_inverse
@@ -2230,12 +2230,12 @@ def load_urdf_file(self, file_obj, include_mimic_joints=True):
             if j.parent not in link_maps or j.child not in link_maps:
                 continue
             if j.origin is None:
-                rpy = np.zeros(3, dtype=np.float32)
+                ypr = np.zeros(3, dtype=np.float32)
                 xyz = np.zeros(3, dtype=np.float32)
             else:
-                rpy = rpy_angle(j.origin[:3, :3])[0]
+                ypr = matrix2ypr(j.origin[:3, :3])
                 xyz = j.origin[:3, 3]
-            link_maps[j.child].newcoords(rpy,
+            link_maps[j.child].newcoords(ypr,
                                          xyz)
             # TODO(fix automatically update default_coords)
             link_maps[j.child].joint.default_coords = Coordinates(

skrobot/planner/utils.py

@@ -2,7 +2,7 @@
 
 from skrobot.coordinates import CascadedCoords
 from skrobot.coordinates import Coordinates
-from skrobot.coordinates.math import rpy_angle
+from skrobot.coordinates.math import matrix2ypr
 from skrobot.coordinates.math import rpy_matrix
 
 
@@ -93,8 +93,7 @@ def get_robot_config(robot_model, joint_list, with_base=False):
     av_joint = np.array([j.joint_angle() for j in joint_list])
     if with_base:
         x, y, _ = robot_model.translation
-        rpy = rpy_angle(robot_model.rotation)[0]
-        theta = rpy[0]
+        theta, _, _ = matrix2ypr(robot_model.rotation)
         av_whole = np.hstack((av_joint, [x, y, theta]))
         return av_whole
     else:

skrobot/sdf/signed_distance_function.py

@@ -534,8 +534,8 @@ def from_objfile(obj_filepath, dim_grid=100, padding_grid=5, **kwargs):
                     'trying to acquire lock for %s...', sdf_cache_path)
                 logger.info(
                     'pre-computing sdf and making a cache at %s.', sdf_cache_path)
-                pysdfgen.obj2sdf(str(obj_filepath), dim_grid, padding_grid,
-                                 output_filepath=sdf_cache_path)
+                pysdfgen.mesh2sdf(str(obj_filepath), dim_grid, padding_grid,
+                                  output_filepath=sdf_cache_path)
                 logger.info('finish pre-computation')
         return GridSDF.from_file(sdf_cache_path, **kwargs)
 

tests/skrobot_tests/coordinates_tests/test_base.py

@@ -216,8 +216,9 @@ def test_translate(self):
         c.translate([0.1, 0.2, 0.3], c2)
         testing.assert_almost_equal(
             c.translation, [0.3, 0.2, -0.1])
+        from skrobot.coordinates.math import matrix2ypr
         testing.assert_almost_equal(
-            c.rpy_angle()[0], [pi / 3.0, 0, 0])
+            matrix2ypr(c.rotation), [pi / 3.0, 0, 0])
 
     def test_transform_vector(self):
         pos = [0.13264493, 0.05263172, 0.93042636]

tests/skrobot_tests/coordinates_tests/test_geo.py

@@ -28,8 +28,9 @@ def test_orient_coords_to_axis(self):
 
         testing.assert_array_equal(target_coords.worldpos(),
                                    [1, 1, 1])
+        from skrobot.coordinates.math import matrix2ypr
         testing.assert_array_almost_equal(
-            target_coords.rpy_angle()[0],
+            matrix2ypr(target_coords.rotation),
             [0, 0, -1.57079633])
 
         # case of rot_angle_cos == 1.0
@@ -39,7 +40,7 @@ def test_orient_coords_to_axis(self):
         testing.assert_array_equal(target_coords.worldpos(),
                                    [1, 1, 1])
         testing.assert_array_almost_equal(
-            target_coords.rpy_angle()[0],
+            matrix2ypr(target_coords.rotation),
             [0, 0, 0])
 
         # case of rot_angle_cos == -1.0
@@ -49,7 +50,7 @@ def test_orient_coords_to_axis(self):
         testing.assert_array_equal(target_coords.worldpos(),
                                    [0, 0, 0])
         testing.assert_array_almost_equal(
-            target_coords.rpy_angle()[0],
+            matrix2ypr(target_coords.rotation),
             [0, 0, pi])
 
     def test_rotate_points(self):

tests/skrobot_tests/coordinates_tests/test_math.py

@@ -9,18 +9,16 @@
 
 from skrobot.coordinates.math import _check_valid_rotation
 from skrobot.coordinates.math import angle_between_vectors
+from skrobot.coordinates.math import axis_angle_vector_to_rotation_matrix
 from skrobot.coordinates.math import clockwise_angle_between_vectors
 from skrobot.coordinates.math import counter_clockwise_angle_between_vectors
 from skrobot.coordinates.math import cross_product
+from skrobot.coordinates.math import interpolate_rotation_matrices
 from skrobot.coordinates.math import invert_yaw_pitch_roll
 from skrobot.coordinates.math import matrix2quaternion
 from skrobot.coordinates.math import matrix2rpy
 from skrobot.coordinates.math import matrix2ypr
-from skrobot.coordinates.math import matrix_exponent
-from skrobot.coordinates.math import matrix_log
-from skrobot.coordinates.math import midrot
 from skrobot.coordinates.math import normalize_vector
-from skrobot.coordinates.math import outer_product_matrix
 from skrobot.coordinates.math import quaternion2matrix
 from skrobot.coordinates.math import quaternion2rpy
 from skrobot.coordinates.math import quaternion_conjugate
@@ -42,11 +40,12 @@
 from skrobot.coordinates.math import rotation_matrix
 from skrobot.coordinates.math import rotation_matrix_from_axis
 from skrobot.coordinates.math import rotation_matrix_from_rpy
+from skrobot.coordinates.math import rotation_matrix_to_axis_angle_vector
 from skrobot.coordinates.math import rotation_vector_to_quaternion
 from skrobot.coordinates.math import rpy2matrix
 from skrobot.coordinates.math import rpy2quaternion
-from skrobot.coordinates.math import rpy_angle
 from skrobot.coordinates.math import rpy_matrix
+from skrobot.coordinates.math import skew_symmetric_matrix
 from skrobot.coordinates.math import triple_product
 from skrobot.coordinates.math import wxyz2xyzw
 from skrobot.coordinates.math import xyzw2wxyz
@@ -104,7 +103,7 @@ def test_midrot(self):
         m1 = rotate_matrix(rotate_matrix(rotate_matrix(
             np.eye(3), 0.2, 'x'), 0.4, 'y'), 0.6, 'z')
         testing.assert_almost_equal(
-            midrot(0.5, m1, np.eye(3)),
+            interpolate_rotation_matrices(0.5, m1, np.eye(3)),
             np.array([[0.937735, -0.294516, 0.184158],
                       [0.319745, 0.939037, -0.126384],
                       [-0.135709, 0.177398, 0.974737]]),
@@ -132,7 +131,7 @@ def test_rpy_matrix(self):
             np.eye(3))
 
     def test_rpy_angle(self):
-        a, b = rpy_angle(rpy_matrix(pi / 6, pi / 5, pi / 3))
+        a, b = matrix2ypr(rpy_matrix(pi / 6, pi / 5, pi / 3)), np.array([3.66519143, 2.51327412, -2.0943951])
         testing.assert_almost_equal(
             a, np.array([pi / 6, pi / 5, pi / 3]))
         testing.assert_almost_equal(
@@ -142,7 +141,7 @@ def test_rpy_angle(self):
                         [0, -1, 0],
                         [1, 0, 0]])
         testing.assert_almost_equal(
-            rpy_angle(rot)[0],
+            matrix2ypr(rot),
             np.array([0, - pi / 2.0, pi]))
 
     def test_rotation_matrix(self):
@@ -192,7 +191,7 @@ def test_rodrigues(self):
         axis = np.array([np.pi, 0, 0], 'f')
         rec_mat = rodrigues(axis)
         testing.assert_array_almost_equal(
-            rpy_angle(rec_mat)[0], np.array([0.0, 0.0, -np.pi], 'f'))
+            matrix2ypr(rec_mat), np.array([0.0, 0.0, -np.pi], 'f'))
 
     def test_rodrigues_batch(self):
         # Creating batch matrices and angles
@@ -256,7 +255,7 @@ def test_rotation_angle(self):
             None)
 
     def test_outer_product_matrix(self):
-        testing.assert_array_equal(outer_product_matrix([1, 2, 3]),
+        testing.assert_array_equal(skew_symmetric_matrix([1, 2, 3]),
                                    np.array([[0.0, -3.0, 2.0],
                                              [3.0, 0.0, -1.0],
                                              [-2.0, 1.0, 0.0]]))
@@ -270,7 +269,7 @@ def test_matrix_exponent(self):
         m1 = rotate_matrix(rotate_matrix(rotate_matrix(
             np.eye(3), 0.2, 'x'), 0.4, 'y'), 0.6, 'z')
         testing.assert_almost_equal(
-            matrix_exponent(matrix_log(m1)), m1,
+            axis_angle_vector_to_rotation_matrix(rotation_matrix_to_axis_angle_vector(m1)), m1,
             decimal=5)
 
     def test_quaternion2matrix(self):