roboticstoolbox-python 1.3.0__cp313-cp313-win_amd64.whl

roboticstoolbox/models/URDF/__init__.py

@@ -0,0 +1,53 @@
+from roboticstoolbox.models.URDF.Panda import Panda
+from roboticstoolbox.models.URDF.Frankie import Frankie
+from roboticstoolbox.models.URDF.FrankieOmni import FrankieOmni
+from roboticstoolbox.models.URDF.UR3 import UR3
+from roboticstoolbox.models.URDF.UR5 import UR5
+from roboticstoolbox.models.URDF.UR10 import UR10
+from roboticstoolbox.models.URDF.Puma560 import Puma560
+from roboticstoolbox.models.URDF.px100 import px100
+from roboticstoolbox.models.URDF.px150 import px150
+from roboticstoolbox.models.URDF.rx150 import rx150
+from roboticstoolbox.models.URDF.rx200 import rx200
+from roboticstoolbox.models.URDF.vx300 import vx300
+from roboticstoolbox.models.URDF.vx300s import vx300s
+from roboticstoolbox.models.URDF.wx200 import wx200
+from roboticstoolbox.models.URDF.wx250 import wx250
+from roboticstoolbox.models.URDF.wx250s import wx250s
+from roboticstoolbox.models.URDF.Mico import Mico
+from roboticstoolbox.models.URDF.PR2 import PR2
+from roboticstoolbox.models.URDF.LBR import LBR
+from roboticstoolbox.models.URDF.KinovaGen3 import KinovaGen3
+from roboticstoolbox.models.URDF.YuMi import YuMi
+from roboticstoolbox.models.URDF.Fetch import Fetch
+from roboticstoolbox.models.URDF.FetchCamera import FetchCamera
+from roboticstoolbox.models.URDF.Valkyrie import Valkyrie
+from roboticstoolbox.models.URDF.AL5D import AL5D
+
+__all__ = [
+    "Panda",
+    "Frankie",
+    "FrankieOmni",
+    "UR3",
+    "UR5",
+    "UR10",
+    "Puma560",
+    "px100",
+    "px150",
+    "rx150",
+    "rx200",
+    "vx300",
+    "vx300s",
+    "wx200",
+    "wx250",
+    "wx250s",
+    "Mico",
+    "PR2",
+    "LBR",
+    "KinovaGen3",
+    "YuMi",
+    "Fetch",
+    "FetchCamera",
+    "Valkyrie",
+    "AL5D",
+]

roboticstoolbox/models/URDF/px100.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class px100(Robot):
+    """
+    Class that imports a PX100 URDF model
+
+    ``px100()`` is a class which imports an Interbotix px100 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.px100()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/px100.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/px100.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4])
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = px100()
+    print(robot)

roboticstoolbox/models/URDF/px150.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class px150(Robot):
+    """
+    Class that imports a PX150 URDF model
+
+    ``px150()`` is a class which imports an Interbotix px150 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.px150()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/px150.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/px150.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = px150()
+    print(robot)

roboticstoolbox/models/URDF/rx150.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class rx150(Robot):
+    """
+    Class that imports a RX150 URDF model
+
+    ``rx150()`` is a class which imports an Interbotix rx150 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.rx150()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/rx150.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/rx150.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = rx150()
+    print(robot)

roboticstoolbox/models/URDF/rx200.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class rx200(Robot):
+    """
+    Class that imports a RX200 URDF model
+
+    ``rx200()`` is a class which imports an Interbotix rx200 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.rx200()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/rx200.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/rx200.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(7)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = rx200()
+    print(robot)

roboticstoolbox/models/URDF/vx300.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class vx300(Robot):
+    """
+    Class that imports a VX300 URDF model
+
+    ``vx300()`` is a class which imports an Interbotix vx300 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.vx300()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/vx300.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/vx300.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = vx300()
+    print(robot)

roboticstoolbox/models/URDF/vx300s.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class vx300s(Robot):
+    """
+    Class that imports a VX300s URDF model
+
+    ``vx300s()`` is a class which imports an Interbotix vx300s robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.vx300s()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/vx300s.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/vx300s.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0, 0])
+        self.qz = np.zeros(9)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = vx300s()
+    print(robot)

roboticstoolbox/models/URDF/wx200.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class wx200(Robot):
+    """
+    Class that imports a WX200 URDF model
+
+    ``wx200()`` is a class which imports an Interbotix wx200 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.wx200()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/wx200.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/wx200.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = wx200()
+    print(robot)

roboticstoolbox/models/URDF/wx250.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class wx250(Robot):
+    """
+    Class that imports a WX250 URDF model
+
+    ``wx250()`` is a class which imports an Interbotix wx250 robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.wx250()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/wx250.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/wx250.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0])
+        self.qz = np.zeros(8)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = wx250()
+    print(robot)

roboticstoolbox/models/URDF/wx250s.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+import numpy as np
+from roboticstoolbox.robot.Robot import Robot
+
+
+class wx250s(Robot):
+    """
+    Class that imports a wx250s URDF model
+
+    ``wx250s()`` is a class which imports an Interbotix wx250s robot definition
+    from a URDF file.  The model describes its kinematic and graphical
+    characteristics.
+
+    .. runblock:: pycon
+
+        >>> import roboticstoolbox as rtb
+        >>> robot = rtb.models.URDF.wx250s()
+        >>> print(robot)
+
+    Defined joint configurations are:
+
+    - qz, zero joint angle configuration, 'L' shaped configuration
+    - qr, vertical 'READY' configuration
+
+    :reference:
+        - https://docs.trossenrobotics.com/interbotix_xsarms_docs/specifications/wx250s.html
+
+    .. codeauthor:: Jesse Haviland
+    .. sectionauthor:: Peter Corke
+    """
+
+    def __init__(self):
+
+        links, name, urdf_string, urdf_filepath = self.URDF_read(
+            "interbotix_descriptions/urdf/wx250s.urdf.xacro"
+        )
+
+        super().__init__(
+            links,
+            name=name,
+            manufacturer="Interbotix",
+            urdf_string=urdf_string,
+            urdf_filepath=urdf_filepath,
+        )
+
+        self.qr = np.array([0, -0.3, 0, -2.2, 0, 2.0, np.pi / 4, 0, 0])
+        self.qz = np.zeros(9)
+
+        self.addconfiguration("qr", self.qr)
+        self.addconfiguration("qz", self.qz)
+
+
+if __name__ == "__main__":  # pragma nocover
+    robot = wx250s()
+    print(robot)

roboticstoolbox/models/__init__.py

@@ -0,0 +1,7 @@
+from roboticstoolbox.models.URDF import *  # noqa
+from roboticstoolbox.models import ETS  # noqa
+from roboticstoolbox.models import DH  # noqa
+from roboticstoolbox.models.list import list
+
+
+__all__ = ["list", "ETS", "DH"]

roboticstoolbox/models/list.py

@@ -0,0 +1,119 @@
+from typing import Type
+from roboticstoolbox.robot.Robot import Robot
+from roboticstoolbox.tools import rtb_get_param
+from roboticstoolbox.robot.ERobot import ERobot2
+from ansitable import ANSITable, Column
+import inspect
+
+# import importlib
+
+
+def list(keywords=None, dof=None, type=None, border="thin"):
+    """
+    Display all robot models in summary form
+
+    :param keywords: keywords to filter on, defaults to None
+    :type keywords: tuple of str, optional
+    :param dof: number of DoF to filter on, defaults to None
+    :type dof: int, optional
+    :param type: model type "DH", "ETS", "URDF", defaults to all types
+    :type type: str, optional
+
+    - ``list()`` displays a list of all models provided by the Toolbox.  It
+      lists the name, manufacturer, model type, number of DoF, and keywords.
+
+    - ``list(type=MT)`` as above, but only displays models of type ``MT``
+      where ``MT`` is one of "DH", "ETS" or "URDF".
+
+    - ``list(keywords=KW)`` as above, but only displays models that have a
+      keyword in the tuple ``KW``.
+
+    - ``list(dof=N)`` as above, but only display models that have ``N``
+      degrees of freedom.
+
+    The filters can be combined
+
+    - ``list(keywords=KW, dof=N)`` are those models that have a keyword in
+      ``KW`` and have ``N`` degrees of freedom.
+    """
+
+    import roboticstoolbox.models as models
+
+    # module = importlib.import_module(
+    #   '.' + os.path.splitext(file)[0], package='bdsim.blocks')
+
+    unicode = rtb_get_param("unicode")
+    if not unicode:
+        border = "ascii"
+
+    def make_table(border=None):
+        table = ANSITable(
+            Column("class", headalign="^", colalign="<"),
+            Column("name", headalign="^", colalign="<"),
+            Column("manufacturer", headalign="^", colalign="<"),
+            Column("type", headalign="^", colalign="<"),
+            Column("DoF", colalign="<"),
+            Column("dims", colalign="<"),
+            Column("structure", colalign="<"),
+            Column("dynamics", colalign="<"),
+            Column("geometry", colalign="<"),
+            Column("keywords", headalign="^", colalign="<"),
+            border=border,
+        )
+
+        if type is not None:
+            categories = [type]
+        else:
+            categories = ["DH", "URDF", "ETS"]
+        for category in categories:
+            # get all classes in this category
+            group = models.__dict__[category]
+            for cls in group.__dict__.values():
+                if inspect.isclass(cls) and issubclass(cls, Robot):
+                    # we found a BaseRobot subclass, instantiate it
+                    try:
+                        robot = cls()
+                    except TypeError:
+                        print(f"failed to load {cls}")
+                    try:
+                        structure = robot.structure
+                    except Exception:  # pragma nocover
+                        structure = ""
+
+                    # apply filters
+                    if keywords is not None:
+                        if len(set(keywords) & set(robot.keywords)) == 0:
+                            continue
+                    if dof is not None and robot.n != dof:
+                        continue  # pragma nocover
+
+                    dims = 0
+
+                    if isinstance(robot, ERobot2):
+                        dims = 2
+                    else:
+                        dims = 3
+                    # add the row
+                    table.row(
+                        cls.__name__,
+                        robot.name,
+                        robot.manufacturer,
+                        category,
+                        robot.n,
+                        f"{dims}d",
+                        structure,
+                        "Y" if robot._hasdynamics else "",
+                        "Y" if robot._hasgeometry else "",
+                        ", ".join(robot.keywords),
+                    )
+
+        table.print()
+
+    make_table(border=border)
+
+
+if __name__ == "__main__":  # pragma nocover
+    list(border="ascii")
+    list(keywords=("dynamics",), border="thin")
+    list(dof=6)
+    list(keywords=("dynamics",), dof=6)