urdfeus 0.0.6__py3-none-any.whl

urdfeus/__init__.py

@@ -0,0 +1,6 @@
+# flake8: noqa
+
+import pkg_resources
+
+
+__version__ = pkg_resources.get_distribution("urdfeus").version

urdfeus/apps/mesh2eus.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+import argparse
+
+from urdfeus.mesh2eus import mesh2eus
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert mesh to Euslisp')
+    parser.add_argument('input_mesh_path', type=str,
+                        help='Input mesh file path')
+    parser.add_argument('output_euslisp_path', type=str,
+                        help='Output Euslisp path')
+    parser.add_argument(
+        '--simplify-vertex-clustering-voxel-size', '--voxel-size',
+        default=None,
+        type=float,
+        help='Specifies the voxel size for the simplify_vertex_clustering'
+        ' function in open3d. When this value is provided, '
+        'it is used as the voxel size in the function to perform '
+        'mesh simplification. This process reduces the complexity'
+        ' of the mesh by clustering vertices within the specified voxel size.')
+    args = parser.parse_args()
+    with open(args.output_euslisp_path, 'w') as f:
+        mesh2eus(args.input_mesh_path,
+                 args.simplify_vertex_clustering_voxel_size,
+                 fp=f)
+
+
+if __name__ == '__main__':
+    main()

urdfeus/apps/urdf2eus.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+import argparse
+
+from urdfeus.urdf2eus import urdf2eus
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert URDF to Euslisp')
+    parser.add_argument('input_urdf_path', type=str, help='Input URDF path')
+    parser.add_argument('output_euslisp_path', type=str,
+                        help='Output Euslisp path')
+    parser.add_argument('--yaml-path', type=str,
+                        default=None,
+                        help='Config yaml path')
+    parser.add_argument(
+        '--simplify-vertex-clustering-voxel-size', '--voxel-size',
+        default=None,
+        type=float,
+        help='Specifies the voxel size for the simplify_vertex_clustering'
+        ' function in open3d. When this value is provided, '
+        'it is used as the voxel size in the function to perform '
+        'mesh simplification. This process reduces the complexity'
+        ' of the mesh by clustering vertices within the specified voxel size.')
+    args = parser.parse_args()
+    with open(args.output_euslisp_path, 'w') as f:
+        urdf2eus(args.input_urdf_path,
+                 args.yaml_path,
+                 args.simplify_vertex_clustering_voxel_size,
+                 fp=f)
+
+
+if __name__ == '__main__':
+    main()

urdfeus/common.py

@@ -0,0 +1,23 @@
+from skrobot.model import FixedJoint
+from skrobot.model import Joint
+
+
+meter2millimeter = 1000.0
+
+
+def is_linear_joint(joint: Joint) -> bool:
+    return joint.__class__.__name__ == 'LinearJoint'
+
+
+def is_fixed_joint(joint: Joint) -> bool:
+    return joint.__class__.__name__ == 'FixedJoint'
+
+
+def collect_all_joints_of_robot(robot):
+    """Collects and returns all joints of the robot, including fixed joints.
+
+    """
+    all_fixed_joints = [value for _, value in robot.__dict__.items()
+                        if isinstance(value, FixedJoint)]
+    all_joints = robot.joint_list + all_fixed_joints
+    return all_joints

urdfeus/mesh2eus.py

@@ -0,0 +1,29 @@
+import os.path as osp
+import sys
+import tempfile
+
+from urdfeus.templates.urdf_template import urdf_template
+from urdfeus.urdf2eus import urdf2eus
+
+
+def mesh2eus(mesh_path, simplify_vertex_clustering_voxel_size=None,
+             fp=sys.stdout, mesh_name=None):
+    if mesh_name is None:
+        mesh_name, _ = osp.splitext(osp.basename(mesh_path))
+    collision_mesh_filepath = osp.abspath(mesh_path)
+    visual_mesh_filepath = osp.abspath(mesh_path)
+
+    formatted_urdf = urdf_template.format(
+        mesh_name=mesh_name,
+        collision_mesh_filepath=collision_mesh_filepath,
+        visual_mesh_filepath=visual_mesh_filepath
+    )
+
+    with tempfile.NamedTemporaryFile(delete=True) as temp:
+        temp_urdf_path = temp.name
+        temp.write(formatted_urdf.encode('utf-8'))
+        temp.seek(0)
+        voxel_size = simplify_vertex_clustering_voxel_size
+        urdf2eus(temp_urdf_path,
+                 simplify_vertex_clustering_voxel_size=voxel_size,
+                 fp=fp)

urdfeus/read_yaml.py

@@ -0,0 +1,165 @@
+import sys
+
+import yaml
+
+from urdfeus.common import meter2millimeter
+
+
+def read_config_from_yaml(
+        robot, config_file,
+        fp=sys.stdout, add_link_suffix=True, add_joint_suffix=True):
+    print('\n', end='', file=fp)
+    with open(config_file, 'r') as file:
+        doc = yaml.load(file, Loader=yaml.FullLoader)
+
+    for limb in [k for k in doc.keys() if k.endswith('-end-coords')]:
+        suffix_to_remove = '-end-coords'
+        limb_name = limb[:-len(suffix_to_remove)]
+        end_coords_parent_name = doc[f"{limb_name}-end-coords"]["parent"]
+
+        if add_link_suffix:
+            print(f"     (setq {limb_name}-end-coords (make-cascoords :coords (send {end_coords_parent_name}_lk :copy-worldcoords) :name :{limb_name}-end-coords))", file=fp)  # NOQA
+        else:
+            print(f"     (setq {limb_name}-end-coords (make-cascoords :coords (send {end_coords_parent_name} :copy-worldcoords) :name {limb_name}-end-coords))", file=fp)  # NOQA
+
+        try:
+            n = doc[f"{limb_name}-end-coords"]["translate"]
+            values = [meter2millimeter * val for val in n[:3]]
+            print(f"     (send {limb_name}-end-coords :translate (float-vector {' '.join(map(str, values))}))", file=fp)  # NOQA
+        except Exception as _:  # NOQA
+            pass
+
+        try:
+            n = doc[f"{limb_name}-end-coords"]["rotate"]
+            if n:
+                values = [val for val in n[:3]]
+                rotation_value = (3.141592653589793/180) * n[3]
+                print(f"     (send {limb_name}-end-coords :rotate {rotation_value} (float-vector {' '.join(map(str, values))}))", file=fp)  # NOQA
+        except Exception as _:  # NOQA
+            pass
+
+        if add_link_suffix:
+            print(f"     (send {end_coords_parent_name}_lk :assoc {limb_name}-end-coords)", file=fp)  # NOQA
+        else:
+            print(f"     (send {end_coords_parent_name} :assoc {limb_name}-end-coords)", file=fp)  # NOQA
+
+    print("", file=fp)
+    print("     ;; limbs", file=fp)
+
+    limb_candidates = [k for k in doc.keys()
+                       if not k.endswith('-coords')
+                       and not k.endswith('-vector')]
+    limb_order = [(limb, idx) for idx, limb in enumerate(limb_candidates)]
+    limb_order.sort(key=lambda x: x[1])
+
+    limbs = []
+    for limb, _ in limb_order:
+        limb_name = limb
+        tmp_link_names = []
+        tmp_joint_names = []
+        try:
+            limb_doc = doc[limb_name]
+        except Exception as _:  # NOQA
+            continue
+
+        for item in limb_doc:
+            for key, value in item.items():
+                if key in robot.__dict__:
+                    joint = robot.__dict__[key]
+                    tmp_joint_names.append(key)
+                    tmp_link_names.append(joint.child_link.name)
+        if tmp_link_names:
+            print(f"     (setq {limb_name} (list", end="", file=fp)
+            if add_link_suffix:
+                for link in tmp_link_names:
+                    print(f" {link}_lk", end="", file=fp)
+            else:
+                for link in tmp_link_names:
+                    print(f" {link}", end="", file=fp)
+            print("))", file=fp)
+            print("", file=fp)
+
+            print(f"     (setq {limb_name}-root-link", file=fp)
+            print(f"           (labels ((find-parent (l) (if (find (send l :parent) {limb_name}) (find-parent (send l :parent)) l)))", file=fp)  # NOQA
+            print(f"             (find-parent (car {limb_name}))))", file=fp)
+        limbs.append((limb, (tmp_link_names, tmp_joint_names)))
+    print("", file=fp)
+    print("     ;; links", file=fp)
+    if add_link_suffix:
+        print(f"     (setq links (list {robot.__dict__['root_link'].name}_lk", end="", file=fp)  # NOQA
+    else:
+        print(f"     (setq links (list {robot.__dict__['root_link'].name}", end="", file=fp)  # NOQA
+
+    for limb, (link_names, joint_names) in limbs:
+        if add_link_suffix:
+            for link in link_names:
+                print(f" {link}_lk", end="", file=fp)
+        else:
+            for link in link_names:
+                print(f" {link}", end="", file=fp)
+
+    print("))", file=fp)
+    print("", file=fp)
+    print("     ;; joint-list", file=fp)
+    print("     (setq joint-list (list", end="", file=fp)
+    for limb, (link_names, joint_names) in limbs:
+        if add_joint_suffix:
+            for joint in joint_names:
+                print(f" {joint}_jt", end="", file=fp)
+        else:
+            for joint in joint_names:
+                print(f" {joint}", end="", file=fp)
+    print("))", file=fp)
+    print("", file=fp)
+
+    print("     ;; init-ending\n", file=fp)
+    print("     (send self :init-ending) ;; :urdf\n", file=fp)
+    print("     ;; overwrite bodies to return draw-things links not (send link :bodies)\n", file=fp)  # NOQA
+    print("     (setq bodies (flatten (mapcar #'(lambda (b) (if (find-method b :bodies) (send b :bodies))) (list", end="", file=fp)  # NOQA
+    for link in robot.link_list:
+        if add_link_suffix:
+            print(f" {link.name}_lk", end="", file=fp)
+        else:
+            print(f" {link.name}", end="", file=fp)
+    print("))))\n", file=fp)
+
+    print("     (when (member :reset-pose (send self :methods))", file=fp)
+    print("           (send self :reset-pose)) ;; :set reset-pose\n", file=fp)
+    print("     self)) ;; end of :init", file=fp)
+
+    if 'angle-vector' in doc:
+        n = doc['angle-vector']
+        if len(n) > 0:
+            print("  ;; pre-defined pose methods\n", file=fp)
+
+        for name, v in n.items():
+            limbs_symbols = " ".join([f":{limb[0]}" for limb in limbs])
+            print(f"\n    (:{name} (&optional (limbs '({limbs_symbols})))\n",
+                  file=fp)
+            print(f"      \"Predefined pose named {name}.\"\n", file=fp)
+            print("      (unless (listp limbs) (setq limbs (list limbs)))\n",
+                  file=fp)
+            print("      (dolist (limb limbs)\n", file=fp)
+            print("        (case limb", file=fp)
+
+            i_joint = 0
+            for limb in limbs:
+                limb_name = limb[0]
+                print(f"\n          (:{limb_name} (send self limb :angle-vector (float-vector", file=fp)  # NOQA
+                joint_names = limb[1][1]
+
+                for j in range(len(joint_names)):
+                    try:
+                        angle_value = v[i_joint]
+                        print(f" {angle_value}", file=fp)
+                        i_joint += 1
+                    except IndexError as e:  # NOQA
+                        sys.stderr.write("****** Angle-vector may be shorter than joint-list, please fix .yaml ******\n")  # NOQA
+                        while j < len(joint_names):
+                            print(" 0.0", file=fp)  # padding dummy
+                            j += 1
+
+                print(")))", file=fp)
+
+            print("\n          (t (format t \"Unknown limb is passed: ~a~%\" limb))", file=fp)  # NOQA
+            print("))\n      (send self :angle-vector))", file=fp)

urdfeus/templates/__init__.py

@@ -0,0 +1,9 @@
+import os.path as osp
+
+
+data_dir = osp.abspath(osp.dirname(__file__))
+
+
+def get_euscollada_string():
+    with open(osp.join(data_dir, 'euscollada-robot.l')) as f:
+        return f.read()

urdfeus/templates/euscollada-robot.l

@@ -0,0 +1,241 @@
+;;
+;; copy euscollada-robot class definition from euscollada/src/euscollada-robot.l
+;;
+(defclass euscollada-robot
+  ;; This euscollada-robot class is for robots converted from collada files.
+  ;; This class provides :init-ending override.
+  :super robot-model
+  :slots ())
+
+(defmethod euscollada-robot
+  (:init-ending
+   (&optional (type :urdf))
+   (when (eq type :collada)
+     ;; fix all links' mass properties ;; root link relative (collada) -> link local (euslisp)
+     (dolist (l (append links
+                        (mapcan #'(lambda (x) (if (and (derivedp (cdr x) bodyset-link)
+                                                       (not (memq (cdr x) links)))
+                                                  (list (cdr x)))) (send self :slots))))
+       (unless (= (send l :weight) 0.0)
+         (setq (l . acentroid) (send l :inverse-transform-vector
+                                     (send (send (car links) :worldcoords) :transform-vector
+                                           (l . acentroid))))
+         (setq (l . inertia-tensor) (m* (transpose (send l :worldrot))
+                                        (m* (send (car links) :worldrot)
+                                            (l . inertia-tensor)))))))
+   (send-super :init-ending)
+   (send self :make-collision-model-for-links)
+   ;;
+   (dolist (j (mapcan #'(lambda (x) (if (and (derivedp (cdr x) joint)
+                                             (not (memq (cdr x) (send self :joint-list))))
+                                        (list (cdr x)))) (send self :slots)))
+     (send (send j :child-link) :add-joint j)
+     (send (send j :child-link) :add-parent-link (send j :parent-link))
+     (send (send j :parent-link) :add-child-links (send j :child-link))))
+  (:change-visual
+   (&optional (visual :convex))
+   (dolist (lk (send self :links))
+     (dolist (bd (send lk :bodies))
+       (when (derivedp bd collada-body)
+         (send bd :change-visual visual)))))
+  ;; fullbody-inverse-kinematics overwrite
+  ;;  reduce root-link's weight based on leg's joint limit
+  ;;  increase stop and cog-gain
+  (:fullbody-inverse-kinematics
+   (target-coords &rest args &key (stop 250) (cog-gain 2.0) (additional-weight-list) (use-6dof-joint-leg-gain nil) &allow-other-keys)
+   (let* ((leg-ul (send self :calc-union-link-list (send self :legs :links))))
+     (send self :reset-joint-angle-limit-weight-old leg-ul)
+     (send-message* self robot-model :fullbody-inverse-kinematics
+                    target-coords
+                    :stop stop :cog-gain cog-gain
+                    :additional-weight-list
+                    (append
+                     additional-weight-list
+                     (if use-6dof-joint-leg-gain
+                         (list
+                          (list (car (send self :links))
+                                #'(lambda ()
+                                    ;; set root-link 6dof-joint's weight based on legs' joint limit
+                                    (let* ((min-weight
+                                            (reduce #'(lambda (x y) (min x y))
+                                                    (coerce (send self :calc-inverse-kinematics-weight-from-link-list
+                                                                  leg-ul :union-link-list leg-ul) cons))))
+                                      (fill (instantiate float-vector 6) min-weight)))))))
+                    args)))
+  ;; make collision model from faces or gl-vertices
+  (:make-collision-model-for-links
+   (&key (fat 0) (collision-func 'pqp-collision-check) ((:links ls) (send self :links)))
+   (dolist (ll ls)
+     (let (fs glv usefs)
+       (dolist (bd (send ll :bodies))
+         (if (derivedp bd collada-body)
+             (push (send bd :glvertices) glv)
+           (push (send bd :faces) fs)))
+       (setq fs (flatten fs))
+       (cond
+        ((and (not fs) glv) ;; if there is no faces, use glvertices for creating pqpmodel
+         (setq usefs (instance gl::glvertices :init nil))
+         (send usefs :transform (send ll :worldcoords))
+         (send usefs :append-glvertices glv)
+         (let ((m (send usefs (read-from-string
+                               (format nil ":make-~Amodel"
+                                       (string-right-trim "-COLLISION-CHECK" (string collision-func))))
+                        :fat fat)))
+           (setf (get ll :pqpmodel) m)))
+        (fs
+         (setq usefs
+               (append fs
+                       (mapcar #'(lambda (gv) (send gv :convert-to-faces :wrt :world)) glv)))
+         (send ll
+               (read-from-string
+                (format nil ":make-~Amodel"
+                        (string-right-trim "-COLLISION-CHECK" (string collision-func))))
+               :fat fat
+               :faces usefs)))))))
+
+;; copy euscollada-body class definition from euscollada/src/euscollada-robot.l
+;; This euscollada-body class is for bodies in robot model converted from collada files.
+(defclass collada-body
+  :super gl::glbody
+  :slots (glvertices) ;; glvertices slot for backward compatibility
+  )
+(defmethod collada-body
+  (:init (&key (name) (replace-obj))
+         (if replace-obj
+             (replace-object self replace-obj)
+           (replace-object self (make-cube 10 10 10)))
+         (if name (send self :name name))
+         (setq glvertices gl::aglvertices)
+         self)
+  (:change-visual
+   (&optional (visual :convex))
+   (case visual
+         ((list :convex :hull :convex-hull)
+          (unless (send self :get :original-mesh)
+            (send self :put :original-mesh gl::aglvertices)) ;; store original mesh
+          (let* ((org-mesh (send self :get :original-mesh))
+                 (org-cds (send org-mesh :copy-worldcoords))
+                 (glv (gl::make-glvertices-from-faces (send self :faces))))
+            (send glv :set-offset (send org-cds :inverse-transformation))
+            (send glv :transform org-cds)
+            (send org-mesh :assoc glv)
+            (setq gl::aglvertices glv)
+            glv))
+         ((list :original :mesh :glvertices :original-mesh)
+          (let ((org-mesh (send self :get :original-mesh)))
+            (when org-mesh
+              (dolist (d (send org-mesh :descendants)) ;; dissoc all discendants
+                (send org-mesh :dissoc d))
+              (setq gl::aglvertices org-mesh)
+              org-mesh))))))
+
+;; copy mimic-joint class definition from euscollada/src/euscollada-robot.l
+;; This mimic-joint class is for mimic-joints in URDF file
+(defclass mimic-joint-param
+  :super propertied-object
+  :slots (joint multiplier offset))
+(defmethod mimic-joint-param
+  (:init (j &key ((:multiplier m) 1) ((:offset o) 0))
+         (setq joint j multiplier m offset o)
+         self)
+  (:joint (&rest args) (forward-message-to joint args))
+  (:multiplier (&rest args) (forward-message-to multiplier args))
+  (:offset (&rest args) (forward-message-to offset args)))
+
+(defun calc-jacobian-mimic
+    (mimic-joints
+     fik row column joint paxis child-link world-default-coords child-reverse
+     move-target transform-coords rotation-axis translation-axis
+     tmp-v0 tmp-v1 tmp-v2 tmp-v3 tmp-v3a tmp-v3b tmp-m33)
+  (let* ((fik-tmp (copy-object fik))
+         (dim (* 6 (if (atom rotation-axis) 1 (length rotation-axis)))))
+    (dolist (axis (append (if (atom translation-axis)
+                              (list translation-axis) translation-axis)
+                          (if (atom rotation-axis)
+                              (list rotation-axis) rotation-axis)))
+      (case axis
+            ((:x :y :z :xx :yy :zz) (decf dim 1))
+            ((:xy :yx :yz :zy :zx :xz) (decf dim 2))
+            (nil (decf dim 3))))
+    ;;
+    (dolist (mj mimic-joints)
+      (let* ((j (send mj :joint))
+             (paxis (case (j . axis)
+                          (:x #f(1 0 0)) (:y #f(0 1 0)) (:z #f(0 0 1))
+                          (:xx #f(1 0 0)) (:yy #f(0 1 0)) (:zz #f(0 0 1))
+                          (:-x #f(-1 0 0)) (:-y #f(0 -1 0)) (:-z #f(0 0 -1))
+                          (t (j . axis))))
+             (child-link (send j :child-link))
+             (parent-link (send j :parent-link))
+             (default-coords (j . default-coords))
+             (world-default-coords (send (send parent-link :copy-worldcoords)
+                                         :transform default-coords)))
+        (fill (array-entity fik-tmp) 0)
+        (send j :calc-jacobian
+              fik-tmp row column j paxis child-link world-default-coords child-reverse
+              move-target transform-coords rotation-axis translation-axis
+              tmp-v0 tmp-v1 tmp-v2 tmp-v3 tmp-v3a tmp-v3b tmp-m33)
+        ;;
+        (dotimes (i dim)
+          (setf (aref fik (+ i row) column)
+                (+ (aref fik (+ i row) column)
+                   (* (send mj :multiplier) (aref fik-tmp (+ i row) column)))))))
+    fik))
+
+(defclass rotational-mimic-joint
+  :super rotational-joint
+  :slots (mimic-joints))
+(defmethod rotational-mimic-joint
+  (:init (&rest args &key ((:mimic-joints mjs)) &allow-other-keys)
+         (send-super* :init args)
+         (setq mimic-joints mjs)
+         (dolist (j mimic-joints)
+           (send (send j :joint :child-link) :rotate (send j :offset) ((send j :joint) . axis))
+           (setq ((send j :joint) . default-coords) (send j :joint :child-link :copy-coords)))
+         self)
+  (:joint-angle (&rest args)
+                (prog1
+                    (send-super* :joint-angle args)
+                  (dolist (j mimic-joints)
+                    (send j :joint :joint-angle (* joint-angle (send j :multiplier))))))
+  (:calc-jacobian (fik row column joint paxis child-link world-default-coords child-reverse
+                       move-target transform-coords rotation-axis translation-axis
+                       tmp-v0 tmp-v1 tmp-v2 tmp-v3 tmp-v3a tmp-v3b tmp-m33)
+                  (calc-jacobian-rotational fik row column joint paxis child-link world-default-coords child-reverse
+                                            move-target transform-coords rotation-axis translation-axis
+                                            tmp-v0 tmp-v1 tmp-v2 tmp-v3 tmp-v3a tmp-v3b tmp-m33)
+                  (calc-jacobian-mimic mimic-joints
+                                       fik row column joint paxis child-link world-default-coords child-reverse
+                                       move-target transform-coords rotation-axis translation-axis
+                                       tmp-v0 tmp-v1 tmp-v2 tmp-v3 tmp-v3a tmp-v3b tmp-m33)))
+
+(defclass linear-mimic-joint
+  :super linear-joint
+  :slots (mimic-joints))
+(defmethod linear-mimic-joint
+  (:init (&rest args &key ((:mimic-joints mjs)) &allow-other-keys)
+         (send-super* :init args)
+         (setq mimic-joints mjs)
+         (dolist (j mimic-joints)
+           (send (send j :joint :child-link) :translate (scale (* 1000 (send j :offset)) ((send j :joint) . axis)))
+           (setq ((send j :joint) . default-coords) (send j :joint :child-link :copy-coords)))
+         self)
+  (:joint-angle (&rest args)
+                (prog1
+                    (send-super* :joint-angle args)
+                  (dolist (j mimic-joints)
+                    (send j :joint :joint-angle (* joint-angle (send j :multiplier))))))
+  (:calc-jacobian (fik row column joint paxis child-link world-default-coords child-reverse
+                       move-target transform-coords rotation-axis translation-axis
+                       tmp-v0 tmp-v1 tmp-v2 tmp-v3 tmp-v3a tmp-v3b tmp-m33)
+                  (calc-jacobian-linear fik row column joint paxis child-link world-default-coords child-reverse
+                                        move-target transform-coords rotation-axis translation-axis
+                                        tmp-v0 tmp-v1 tmp-v2 tmp-v3 tmp-v3a tmp-v3b tmp-m33)
+                  (calc-jacobian-mimic mimic-joints
+                                       fik row column joint paxis child-link world-default-coords child-reverse
+                                       move-target transform-coords rotation-axis translation-axis
+                                       tmp-v0 tmp-v1 tmp-v2 tmp-v3 tmp-v3a tmp-v3b tmp-m33)))
+
+;;
+;; end of copy from jsk_model_tools/euscollada/src/euscollada-robot.l
+;;

urdfeus/templates/urdf_template.py

@@ -0,0 +1,23 @@
+urdf_template = """<?xml version="1.0" ?>
+<robot name="{mesh_name}">
+  <link name="link0">
+    <inertial>
+      <origin rpy="0 0 0" xyz="0 0 0" />
+      <mass value="1.0" />
+      <inertia ixx="1.00E+00" ixy="0.00E+00" ixz="0.00E+00" iyy="1.00E+00" iyz="0.00E+00" izz="1.00E+00" />
+    </inertial>
+    <collision>
+      <origin rpy="0 0 0" xyz="0 0 0" />
+      <geometry>
+        <mesh filename="{collision_mesh_filepath}" scale="1 1 1" />
+      </geometry>
+    </collision>
+    <visual>
+      <origin rpy="0 0 0" xyz="0 0 0" />
+      <geometry>
+        <mesh filename="{visual_mesh_filepath}" scale="1 1 1" />
+      </geometry>
+    </visual>
+  </link>
+</robot>
+"""  # NOQA

urdfeus/urdf2eus.py

@@ -0,0 +1,349 @@
+import datetime
+import platform
+import socket
+import sys
+
+import numpy as np
+from skrobot.model import Link
+from skrobot.model import RobotModel
+from skrobot.utils.mesh import simplify_vertex_clustering
+from skrobot.utils.mesh import split_mesh_by_face_color
+import trimesh
+
+from urdfeus.common import collect_all_joints_of_robot
+from urdfeus.common import is_fixed_joint
+from urdfeus.common import is_linear_joint
+from urdfeus.common import meter2millimeter
+from urdfeus.read_yaml import read_config_from_yaml
+from urdfeus.templates import get_euscollada_string
+
+
+def print_link(link: Link, simplify_vertex_clustering_voxel_size=None,
+               add_link_suffix: bool = True, fp=sys.stdout):
+    if add_link_suffix:
+        link_name = link.name + "_lk"
+    else:
+        link_name = link.name
+    print(f"     ;; link: {link_name}", file=fp)
+    print("     (let ((geom-lst (list ", end='', file=fp)
+
+    geom_counter = 0
+    if link.visual_mesh is not None and len(link.visual_mesh) > 0:
+        print(f"(send self :_make_instance_{link.name}_geom{geom_counter})", end='', file=fp)  # NOQA
+        geom_counter += 1
+
+    print(")))", file=fp)
+    print("       (dolist (g (cdr geom-lst)) (send (car geom-lst) :assoc g))", file=fp)  # NOQA
+    print(f"       (setq {link_name}", file=fp)
+    print("             (instance bodyset-link", file=fp)
+    print("                       :init (make-cascoords)", file=fp)
+    print(f"                       :bodies geom-lst", file=fp)  # NOQA
+    print(f"                       :name \"{link.name}\"))", file=fp)
+    print(f"       (progn (send {link_name} :weight 0.0) (setq ({link_name} . acentroid) (float-vector 0 0 0)) (send {link_name} :inertia-tensor #2f((0 0 0)(0 0 0)(0 0 0))))", file=fp)  # NOQA
+
+    print(f"       ;; global coordinates for {link_name}", file=fp)
+    print("       (let ((world-cds (make-coords :pos ", end="", file=fp)
+    x, y, z = meter2millimeter * link.worldpos()
+    print(f"(float-vector {x:.6f} {y:.6f} {z:.6f})", end="", file=fp)
+
+    qw, qx, qy, qz = link.copy_worldcoords().quaternion
+    print(f"\n                                     :rot (quaternion2matrix (float-vector {qw:.6f} {qx:.6f} {qy:.6f} {qz:.6f}))", end="", file=fp)  # NOQA
+    print(")))\n", end='', file=fp)
+    print(f"         (send {link_name} :transform world-cds)))", file=fp)  # NOQA
+    print("\n", end='', file=fp)
+
+
+def print_joint(joint, add_joint_suffix=True, add_link_suffix=True,
+                fp=sys.stdout):
+    linear = is_linear_joint(joint)
+
+    joint_name = joint.name
+    if add_joint_suffix:
+        if is_fixed_joint(joint):
+            joint_name += "_fixed_jt"
+        else:
+            joint_name += "_jt"
+
+    print("\n", end='', file=fp)
+    print(f"     ;; joint: {joint_name}", file=fp)
+    print(f"     (setq {joint_name}", file=fp)
+    print(f"           (instance {'linear-joint' if linear else 'rotational-joint'} :init", file=fp)  # NOQA
+    print(f"                     :name \"{joint.name}\"", file=fp)
+    if add_link_suffix:
+        print(f"                     :parent-link {joint.parent_link.name}_lk :child-link {joint.child_link.name}_lk", file=fp)  # NOQA
+    else:
+        print(f"                     :parent-link {joint.parent_link.name} :child-link {joint.child_link.name}", file=fp)  # NOQA
+
+    x, y, z = joint.axis
+    if x == 0.0 and y == 0.0 and z == 0.0:
+        print("                     :axis (float-vector 1 1 1) ;; fixed joint??", file=fp)  # NOQA
+    else:
+        print(f"                     :axis (float-vector {x:.16f} {y:.16f} {z:.16f})", file=fp)  # NOQA
+
+    min_val = joint.min_angle
+    max_val = joint.max_angle
+    print("                     ", end="", file=fp)
+    if np.isinf(min_val) or np.isinf(max_val):
+        print(":min *-inf* :max *inf*", file=fp)
+    else:
+        if linear:
+            min_angle = meter2millimeter * min_val
+            max_angle = meter2millimeter * max_val
+        else:
+            min_angle = np.rad2deg(min_val)
+            max_angle = np.rad2deg(max_val)
+        min_str = "*-inf*" if min_val == -float('inf') else str(min_angle)
+        max_str = "*inf*" if max_val == float('inf') else str(max_angle)
+        print(f":min {min_str} :max {max_str}", file=fp)
+    print(f"                     :max-joint-velocity {joint.max_joint_velocity}", file=fp)  # NOQA
+    print(f"                     :max-joint-torque {joint.joint_torque}", end='', file=fp)  # NOQA
+    print("))", file=fp)
+
+
+def print_mimic_joints(robot, fp=sys.stdout):
+    print("\n     ;; mimic joint re-definition\n", file=fp)
+    mimic_joint_list = {}
+
+    for j in robot.urdf_robot_model.joints:
+        if j.mimic is None:
+            continue
+        joint_a = robot.__dict__[j.mimic.joint]
+        joint_b = robot.__dict__[j.name]
+        multiplier = j.mimic.multiplier
+        offset = j.mimic.offset
+
+        if joint_a not in mimic_joint_list:
+            mimic_joint_list[joint_a] = []
+        mimic_joint_list[joint_a].append((joint_b, multiplier, offset))
+
+    for mimic_joint, joints in mimic_joint_list.items():
+        linear = is_linear_joint(mimic_joint)
+        print(f"     ;; re-define {mimic_joint.name} as mimic-joint", file=fp)
+        print("     (let (tmp-mimic-joint)", file=fp)
+        joint_type = "linear-mimic-joint" if linear else "rotational-mimic-joint"  # NOQA
+        print(f"       (setq tmp-mimic-joint (replace-object (instance {joint_type} :init :parent-link (make-cascoords) :child-link (make-cascoords) :max-joint-velocity 0 :max-joint-torque 0) {mimic_joint.name}_jt))", file=fp)  # NOQA
+        print(f"       (setq {mimic_joint.name}_jt tmp-mimic-joint))", file=fp)
+        print(f"     (setq ({mimic_joint.name}_jt . mimic-joints)", file=fp)
+        print("           (list", file=fp)
+        for joint, multiplier, offset in joints:
+            print(f"            (instance mimic-joint-param :init {joint.name}_jt :multiplier {multiplier} :offset {offset})", end='', file=fp)  # NOQA
+        print("))", file=fp)
+        print(f"     ;; set offset as default-coords", file=fp)  # NOQA
+        print(f"     (dolist (j ({mimic_joint.name}_jt . mimic-joints))", file=fp)  # NOQA
+        print("       (cond ((derivedp (send j :joint) rotational-joint)", file=fp)  # NOQA
+        print("              (send (send j :joint :child-link) :rotate (send j :offset) ((send j :joint) . axis)))", file=fp)  # NOQA
+        print("             ((derivedp (send j :joint) linear-joint)", file=fp)  # NOQA
+        print("              (send (send j :joint :child-link) :translate (scale (* 1000 (send j :offset)) ((send j :joint) . axis))))", file=fp)  # NOQA
+        print("             (t (error \"unsupported mimic joint ~A\" (send j :joint))))", file=fp)  # NOQA
+        print("       (setq ((send j :joint) . default-coords) (send j :joint :child-link :copy-coords)))", file=fp)  # NOQA
+
+
+def print_geometry(link, simplify_vertex_clustering_voxel_size=None,
+                   fp=sys.stdout):
+    x, y, z = link.translation
+    name = link.name + '_geom' + str(0)
+    print(f'  (:_make_instance_{name} ()', file=fp)
+    print('    (let (geom glv qhull', file=fp)
+    print('          (local-cds (make-coords :pos ', end='', file=fp)
+    print(f'(float-vector {x * meter2millimeter:.6f} {y * meter2millimeter:.6f} {z * meter2millimeter:.6f})', end='', file=fp)  # NOQA
+
+    qw, qx, qy, qz = link.quaternion
+
+    print('\n', end='', file=fp)
+    print(f'                                  :rot (quaternion2matrix ', end='', file=fp)  # NOQA
+    print(f'(float-vector {qw:.6f} {qx:.6f} {qy:.6f} {qz:.6f}))', end='', file=fp)  # NOQA
+    print(')))', file=fp)
+    print("      (setq glv", file=fp)
+    print("       (instance gl::glvertices :init", end='', file=fp)
+    if link.visual_mesh is not None and len(link.visual_mesh) > 0:
+        # TODO(someone): use g.scale
+        print_mesh(link, simplify_vertex_clustering_voxel_size, fp=fp)
+    else:
+        print('))', file=fp)
+    print("      (send glv :transform local-cds)", file=fp)
+    print("      (send glv :calc-normals)", file=fp)
+
+    # TODO(someone) qhull
+    gname = link.name
+    print(f"      (setq geom (instance collada-body :init :replace-obj nil :name \"{gname}\"))", file=fp)  # NOQA
+    print("      (when glv", file=fp)
+    print("        (setq (geom . gl::aglvertices) glv)", file=fp)
+    print("        (send geom :assoc glv))", file=fp)
+    print("      geom))", file=fp)
+
+
+def print_mesh(link, simplify_vertex_clustering_voxel_size=None,
+               fp=sys.stdout):
+    print("\n                 (list ;; mesh list", file=fp)
+    mesh = trimesh.util.concatenate(link.visual_mesh)
+    if simplify_vertex_clustering_voxel_size:
+        mesh = simplify_vertex_clustering(
+            mesh, simplify_vertex_clustering_voxel_size)[0]
+    for input_mesh in split_mesh_by_face_color(mesh):
+        print("                  (list ;; mesh description", file=fp)
+        print("                   (list :type :triangles)", file=fp)
+        print("                   (list :material (list", file=fp)
+        print(f"                    (list :ambient (float-vector {input_mesh.visual.main_color[0] / 255.0} {input_mesh.visual.main_color[1]/ 255.0} {input_mesh.visual.main_color[2]/ 255.0} {input_mesh.visual.main_color[3]/ 255.0}))", file=fp)  # NOQA
+        print(f"                    (list :diffuse (float-vector {input_mesh.visual.main_color[0]/ 255.0} {input_mesh.visual.main_color[1]/ 255.0} {input_mesh.visual.main_color[2]/ 255.0} {input_mesh.visual.main_color[3]/ 255.0}))", end="", file=fp)  # NOQA
+        print("))", file=fp)
+        print("                   (list :indices #i(", end="", file=fp)
+        print(' '.join(map(str, input_mesh.faces.reshape(-1))), end="", file=fp)  # NOQA
+        print("))", file=fp)
+        print(f"                   (list :vertices (let ((mat (make-matrix {len(input_mesh.vertices)} 3))) (fvector-replace (array-entity mat) #f(", end="", file=fp)  # NOQA
+        vertices = np.array(input_mesh.vertices)
+        vertices = link.inverse_transformation().transform_vector(vertices)
+        vertices = meter2millimeter * vertices
+        # Modified the vertex printing format to reduce mesh file size, considering the unit is in millimeters (mm).  # NOQA
+        # Since the coordinates are in mm, having them formatted to just one decimal place is sufficiently precise for most applications.  # NOQA
+        # This change not only preserves the necessary precision for mm-scale measurements but also effectively compresses the data,  # NOQA
+        # resulting in a smaller file size due to reduced numerical precision in the vertex coordinates.  # NOQA
+        print(' '.join(map(lambda x: '{0:.1f}'.format(x),
+                           vertices.reshape(-1))),
+              end='', file=fp)
+        print(")) mat))", end="", file=fp)
+        # TODO(someone) normal
+        print(")", end='', file=fp)
+    print(")))", file=fp)
+
+
+def print_end_coords(robot, config_yaml_path=None,
+                     add_link_suffix=True, add_joint_suffix=True,
+                     fp=sys.stdout):
+    if config_yaml_path is not None:
+        read_config_from_yaml(robot, config_yaml_path, fp=fp)
+    else:
+        print("     ;; init-ending\n", file=fp)
+        print("     (send self :init-ending) ;; :urdf\n", file=fp)
+        print("     ;; overwrite bodies to return draw-things links not (send link :bodies)\n", file=fp)  # NOQA
+        print("     (setq bodies (flatten (mapcar #'(lambda (b) (if (find-method b :bodies) (send b :bodies))) (list", end="", file=fp)  # NOQA
+        for link in robot.link_list:
+            if add_link_suffix:
+                print(f" {link.name}_lk", end="", file=fp)
+            else:
+                print(f" {link.name}", end="", file=fp)
+        print("))))\n", file=fp)
+
+        print("     (when (member :reset-pose (send self :methods))", file=fp)
+        print("           (send self :reset-pose)) ;; :set reset-pose\n", file=fp)  # NOQA
+        print("     self)) ;; end of :init", file=fp)
+
+    print("\n", end='', file=fp)
+    print("  ;; all joints", file=fp)
+    # Assuming URDFDOM_1_0_0_API is a boolean variable
+    for joint in collect_all_joints_of_robot(robot):
+        joint_name = joint.name
+        if add_joint_suffix:
+            if is_fixed_joint(joint):
+                print(f"  (:{joint_name} (&rest args) (forward-message-to {joint_name}_fixed_jt args))", file=fp)  # NOQA
+            else:
+                print(f"  (:{joint_name} (&rest args) (forward-message-to {joint_name}_jt args))", file=fp)  # NOQA
+        else:
+            print(f"  (:{joint_name} (&rest args) (forward-message-to {joint_name} args))", file=fp)  # NOQA
+
+    if add_link_suffix:
+        print("\n  ;; all links forwarding", file=fp)
+        print("  (:links (&rest args)", file=fp)
+        print("   (if (null args) (return-from :links (send-super :links)))", file=fp)  # NOQA
+        print("   (let ((key (car args))\n           (nargs (cdr args)))", file=fp)  # NOQA
+        print("     (unless (keywordp key)\n         (return-from :links (send-super* :links args)))\n       (case key", file=fp)  # NOQA
+
+        for link in robot.link_list:
+            link_name = link.name
+            print(f"       (:{link_name} (forward-message-to {link_name}_lk nargs))", file=fp)  # NOQA
+        print("       (t (send-super* :links args)))))", file=fp)
+
+    print("\n  ;; all links", file=fp)
+    for link in robot.link_list:
+        link_name = link.name
+        if add_link_suffix:
+            print(f"  (:{link_name}_lk (&rest args) (forward-message-to {link_name}_lk args))", file=fp)  # NOQA
+        else:
+            print(f"  (:{link_name} (&rest args) (forward-message-to {link_name} args))", file=fp)  # NOQA
+
+
+def urdf2eus(urdf_path, config_yaml_path=None,
+             simplify_vertex_clustering_voxel_size=None,
+             fp=sys.stdout):
+    r = RobotModel()
+    with open(urdf_path, 'r') as f:
+        r.load_urdf_file(f)
+    robot_name = r.urdf_robot_model.name
+
+    current_time_str = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    print(f""";; DO NOT EDIT THIS FILE
+;;
+;; this file is automatically generated from {urdf_path} on ({sys.platform} {socket.gethostname()} {platform.platform()}) at {current_time_str}
+;;
+""", file=fp)  # NOQA
+
+    print(get_euscollada_string(), file=fp)
+
+    joint_names = []
+    for joint in collect_all_joints_of_robot(r):
+        joint_name = joint.name
+        if is_fixed_joint(joint):
+            joint_name += "_fixed_jt"
+        else:
+            joint_name += "_jt"
+        joint_names.append(joint_name)
+
+    add_link_suffix = True
+    link_list = []
+    for link in r.link_list:
+        if add_link_suffix:
+            link_name = link.name + "_lk"
+        else:
+            link_name = link.name
+        link_list.append(link_name)
+
+    print('\n\n', end='', file=fp)
+    print(f"(defun {robot_name} () (setq *{robot_name}* (instance {robot_name}-robot :init)))", file=fp)  # NOQA
+    print('\n\n', end='', file=fp)
+    print(f"(defclass {robot_name}-robot", file=fp)
+    print("  :super euscollada-robot", file=fp)
+    print("  :slots (;; link names", file=fp)
+    print("          " + " ".join(link_list), file=fp)
+    print("          ;; joint names", file=fp)
+    print("          " + ' '.join(joint_names), file=fp)
+    print("          ;; sensor names", file=fp)
+    print("          ;; non-default limb names", file=fp)
+    print("          ))", file=fp)
+    print('\n\n', end='', file=fp)
+    print(f"(defmethod {r.urdf_robot_model.name}-robot", file=fp)
+    print("  (:init", file=fp)
+    print("   (&rest args)", file=fp)
+    print("   (let ()", file=fp)
+    print(f"     (send-super* :init :name \"{r.urdf_robot_model.name}\" args)", file=fp)  # NOQA
+    print("\n\n", file=fp)
+
+    for link in r.link_list:
+        print_link(link, fp=fp)
+
+    add_link_suffix = True
+    checked_pairs = {}
+    for link in r.link_list:
+        for child_link in link.child_links:
+            if checked_pairs.get((link.name, child_link.name)) \
+               or checked_pairs.get((child_link.name, link.name)):
+                continue
+            if add_link_suffix:
+                print(f"     (send {link.name}_lk :assoc {child_link.name}_lk)", file=fp)  # NOQA
+            else:
+                print(f"     (send {link.name} :assoc {child_link.name})", file=fp)  # NOQA
+            checked_pairs[(link.name, child_link.name)] = True
+    if add_link_suffix:
+        print(f"     (send self :assoc {r.root_link.name}_lk)", file=fp)
+    else:
+        print(f"     (send self :assoc {r.root_link.name})", file=fp)
+
+    for j in collect_all_joints_of_robot(r):
+        print_joint(j, fp=fp)
+    print_mimic_joints(r, fp=fp)
+    print_end_coords(r, config_yaml_path, fp=fp)
+
+    for link in r.link_list:
+        print_geometry(link,
+                       simplify_vertex_clustering_voxel_size, fp=fp)
+    print('  )', file=fp)
+    print(file=fp)
+    print(f'(provide :{robot_name} "({socket.gethostname()} {platform.platform()}) at {current_time_str}")', file=fp)  # NOQA

urdfeus-0.0.6.dist-info/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Iori Yanokura.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

urdfeus-0.0.6.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: urdfeus
+Version: 0.0.6
+Summary: URDF converter for Euslisp
+Home-page: https://github.com/iory/urdfeus
+Author: iory
+Author-email: ab.ioryz@gmail.com
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: open3d
+Requires-Dist: pyglet <=1.5.17
+Requires-Dist: pyyaml
+Requires-Dist: scikit-robot >=0.0.35
+
+# urdfeus

urdfeus-0.0.6.dist-info/RECORD

@@ -0,0 +1,17 @@
+urdfeus/__init__.py,sha256=Ug8GqHUzOXJzq1G1zVEuFRJz4j1t9Ppt-0_vj_masf8,103
+urdfeus/common.py,sha256=bjPU2LrHzwikPZiHIqLwETZI0PjWA-YaLvqEj5R4S3M,621
+urdfeus/mesh2eus.py,sha256=-_90i5jxYlhp2NAiief-L7NzVqYxEY6E4D2omWmQDIo,987
+urdfeus/read_yaml.py,sha256=PUwT-GaSSz0iRnc6pWu-67vaahEcdVEF4ntnPZpNgkU,7032
+urdfeus/urdf2eus.py,sha256=NCRJ7I77NxrWCSys64D7rkn2LLwvzTSBomB3javt9TU,17040
+urdfeus/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+urdfeus/apps/mesh2eus.py,sha256=JKg0flKRsg6RhBvLIlSouVAkuD893PeejH-rhUQmUN4,1112
+urdfeus/apps/urdf2eus.py,sha256=F-S9iuk2S15FLM7F-2RwaoKrWRYVmvL8jmnJLOJ5OP4,1252
+urdfeus/templates/__init__.py,sha256=f118QjZue3fxxsB6YpNbGko1EVAaK_yyAZQhH3mlgUQ,187
+urdfeus/templates/euscollada-robot.l,sha256=dNrCguOD4gqPDsW4Gr4HubS8hDk3bj3twaWrxa9f8MY,12226
+urdfeus/templates/urdf_template.py,sha256=h52qOWOGkkCBERFJ4Aw6grbx-DxFtt9BjCmm5NAm8Yk,674
+urdfeus-0.0.6.dist-info/LICENSE,sha256=32sGF5yxCI5h7Ii-UqFOUAMeChgbTttAvpoW6w3WMQw,1058
+urdfeus-0.0.6.dist-info/METADATA,sha256=tkn3HVVC_n8n9KkdI9Bysd_vJCrmT5Wz1wqxED1--Xc,830
+urdfeus-0.0.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+urdfeus-0.0.6.dist-info/entry_points.txt,sha256=b1PIL8Ps8ryD5iTPfFnbnx3a20BYyO2Y1CpSg7_dfuU,94
+urdfeus-0.0.6.dist-info/top_level.txt,sha256=NaalN7YfuV0m4TT6vNs2efjsgTqY0iyErAU9JQQwuFo,8
+urdfeus-0.0.6.dist-info/RECORD,,

urdfeus-0.0.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

urdfeus-0.0.6.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+mesh2eus = urdfeus.apps.mesh2eus:main
+urdf2eus = urdfeus.apps.urdf2eus:main

urdfeus-0.0.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+urdfeus