Add a bunch of new attributes for Robot object

petercorke · petercorke · commit 745847edd587 · 2021-04-11T17:08:16.000+10:00
diff --git a/roboticstoolbox/robot/DHRobot.py b/roboticstoolbox/robot/DHRobot.py
@@ -497,6 +497,28 @@ def reach(self):
             self._reach = d
         return self._reach
 
+    @property
+    def nbranches(self):
+        """
+        Number of branches
+
+        :return: number of branches in the robot's kinematic tree
+        :rtype: int
+
+        Number of branches in this robot.  
+        
+        Example:
+
+        .. runblock:: pycon
+
+            >>> import roboticstoolbox as rtb
+            >>> robot = rtb.models.DH.Panda()
+            >>> robot.nbranches
+
+        :seealso: :func:`n`, :func:`nlinks`
+        """
+        return 1
+
     def A(self, j, q=None):
         """
         Link forward kinematics
diff --git a/roboticstoolbox/robot/ERobot.py b/roboticstoolbox/robot/ERobot.py
@@ -382,11 +382,25 @@ def n(self):
     def nbranches(self):
         """
         Number of branches
+
         :return: number of branches in the robot's kinematic tree
         :rtype: int
-        Computed as the number of links with zero children
+
+        Number of branches in this robot.  Computed as the number of links with
+        zero children
+        
+        Example:
+
+        .. runblock:: pycon
+
+            >>> import roboticstoolbox as rtb
+            >>> robot = rtb.models.ETS.Panda()
+            >>> robot.nbranches
+
+        :seealso: :func:`n`, :func:`nlinks`
         """
         return self._nbranches
+
 # --------------------------------------------------------------------- #
 
     @property
diff --git a/roboticstoolbox/robot/Robot.py b/roboticstoolbox/robot/Robot.py
@@ -75,6 +75,8 @@ def __init__(
 
         self._hasdynamics = False
         self._hasgeometry = False
+        self._hascollision = False
+
 
         for link in links:
             if not isinstance(link, Link):
@@ -83,13 +85,18 @@ def __init__(
             # add link back to roboto
             link._robot = self
 
-            if link._hasdynamics:
+            if link.hasdynamics:
                 self._hasdynamics = True
+            if link.geometry:
+                self._hasgeometry = []
+            if link.collision:
+                self._hascollision = True
 
             if isinstance(link, rtb.ELink):
                 if len(link.geometry) > 0:
                     self._hasgeometry = True
         self._links = links
+        self._nlinks = len(links)
 
         # Current joint angles of the robot
         self.q = np.zeros(self.n)
@@ -217,9 +224,117 @@ def n(self):
             >>> robot = rtb.models.DH.Puma560()
             >>> robot.n
 
+        :seealso: :func:`nlinks`, :func:`nbranches`
+        """
+        return self._n
+
+    @property
+    def nlinks(self):
+        """
+        Number of links (Robot superclass)
+
+        :return: Number of links
+        :rtype: int
+
+        Example:
+
+        .. runblock:: pycon
+
+            >>> import roboticstoolbox as rtb
+            >>> robot = rtb.models.DH.Puma560()
+            >>> robot.nlinks
+
+        :seealso: :func:`n`, :func:`nbranches`
+        """
+        return self._nlinks
+
+    @abstractproperty
+    def nbranches(self):
+        pass
+
+        """
+        Number of branches (Robot superclass)
+
+        :return: Number of branches
+        :rtype: int
+
+        Example:
+
+        .. runblock:: pycon
+
+            >>> import roboticstoolbox as rtb
+            >>> robot = rtb.models.DH.Puma560()
+            >>> robot.nbranches
+
+        :seealso: :func:`n`, :func:`nlinks`
         """
         return self._n
 
+    @property
+    def hasdynamics(self):
+        """
+        Robot has dynamic parameters (Robot superclass)
+
+        :return: Robot has dynamic parameters
+        :rtype: bool
+
+        At least one link has associated dynamic parameters.
+
+        Example:
+
+        .. runblock:: pycon
+
+            >>> import roboticstoolbox as rtb
+            >>> robot = rtb.models.DH.Puma560()
+            >>> robot.hasdynamics:
+        """
+        return self._hasdynamics
+
+    @property
+    def hasgeometry(self):
+        """
+        Robot has geometry model (Robot superclass)
+
+        :return: Robot has geometry model
+        :rtype: bool
+
+        At least one link has associated mesh to describe its shape.
+
+        Example:
+
+        .. runblock:: pycon
+
+            >>> import roboticstoolbox as rtb
+            >>> robot = rtb.models.DH.Puma560()
+            >>> robot.hasgeometry
+        
+        :seealso: :func:`hascollision`
+        """
+        return self._hasgeometry
+
+    @property
+    def hascollision(self):
+        """
+        Robot has collision model (Robot superclass)
+
+        :return: Robot has collision model
+        :rtype: bool
+
+        At least one link has associated collision model.
+
+        Example:
+
+        .. runblock:: pycon
+
+            >>> import roboticstoolbox as rtb
+            >>> robot = rtb.models.DH.Puma560()
+            >>> robot.hascollision
+
+        :seealso: :func:`hasgeometry`
+        """
+        return self._hascollision
+
+
     @property
     def qrandom(self):
         """
@@ -330,7 +445,8 @@ def structure(self):
 
         return ''.join(structure)
 
-    def isrevolute(self):
+    @property
+    def revolutejoints(self):
         """
         Revolute joints as bool array
 
@@ -343,16 +459,27 @@ def isrevolute(self):
 
             >>> import roboticstoolbox as rtb
             >>> puma = rtb.models.DH.Puma560()
-            >>> puma.isrevolute()
+            >>> puma.revolutejoints()
             >>> stanford = rtb.models.DH.Stanford()
-            >>> stanford.isrevolute()
+            >>> stanford.revolutejoints()
 
         .. note:: Fixed joints, that maintain a constant link relative pose,
             are not included.  ``len(self.structure) == self.n``.
+
+        :seealso: :func:`Link.isrevolute`, :func:`prismaticjoints` 
         """
-        return [link.isrevolute for link in self]
+        return [link.isrevolute for link in self if link.isjoint]
+
+    # TODO not very efficient
+    # TODO keep a mapping from joint to link
+    def isrevolute(self, j):
+        return self.revolutejoints[j]
 
-    def isprismatic(self):
+    def isprismatic(self, j):
+        return self.prismaticjoints[j]
+
+    @property
+    def prismaticjoints(self):
         """
         Revolute joints as bool array
 
