Merge branch 'master' of https://github.com/petercorke/robotics-toolbox-python

Author: petercorke

examples/VPython.py

@@ -4,7 +4,7 @@
 """
 
 import roboticstoolbox as rp
-import time
+# import time
 
 env = rp.backend.VPython()
 env.launch()

roboticstoolbox/backend/Dynamixel/dynamixel_sdk/protocol1_packet_handler.py

@@ -130,7 +130,7 @@ def txPacket(self, port, txpacket):
     def rxPacket(self, port):
         rxpacket = []
 
-        result = COMM_TX_FAIL
+        result = COMM_TX_FAIL    # lgtm [py/multiple-definition]
         checksum = 0
         rx_length = 0
         wait_length = 6  # minimum length (HEADER0 HEADER1 ID LENGTH ERROR CHKSUM)
@@ -310,7 +310,7 @@ def readTx(self, port, dxl_id, address, length):
         return result
 
     def readRx(self, port, dxl_id, length):
-        result = COMM_TX_FAIL
+        result = COMM_TX_FAIL       # lgtm [py/multiple-definition]
         error = 0
 
         rxpacket = None

roboticstoolbox/backend/Dynamixel/dynamixel_sdk/protocol2_packet_handler.py

@@ -249,7 +249,7 @@ def txPacket(self, port, txpacket):
     def rxPacket(self, port):
         rxpacket = []
 
-        result = COMM_TX_FAIL
+        result = COMM_TX_FAIL  # lgtm [py/multiple-definition]
         rx_length = 0
         wait_length = 11  # minimum length (HEADER0 HEADER1 HEADER2 RESERVED ID LENGTH_L LENGTH_H INST ERROR CRC16_L CRC16_H)
 
@@ -438,7 +438,7 @@ def broadcastPing(self, port):
                         return data_list, result
 
                 else:
-                    result = COMM_RX_CORRUPT
+                    result = COMM_RX_CORRUPT   # lgtm [py/multiple-definition]
 
                     # remove header (0xFF 0xFF 0xFD)
                     del rxpacket[0: 3]
@@ -450,7 +450,7 @@ def broadcastPing(self, port):
                 rx_length = rx_length - idx
 
         # FIXME: unreachable code
-        return data_list, result
+        return data_list, result     # lgtm [py/unreachable-statement]
 
     def action(self, port, dxl_id):
         txpacket = [0] * 10
@@ -526,7 +526,7 @@ def readTx(self, port, dxl_id, address, length):
         return result
 
     def readRx(self, port, dxl_id, length):
-        result = COMM_TX_FAIL
+        result = COMM_TX_FAIL   # lgtm [py/multiple-definition]
         error = 0
 
         rxpacket = None

roboticstoolbox/backend/VPython/VPython.py

@@ -3,26 +3,51 @@
 @author Micah Huth
 """
 
+import importlib
 from roboticstoolbox.backend.Connector import Connector
-
 from roboticstoolbox.robot.DHLink import DHLink
 from roboticstoolbox.robot.Robot import Robot as r
 
-from roboticstoolbox.backend.VPython.canvas import GraphicsCanvas3D, \
-    GraphicsCanvas2D
-from roboticstoolbox.backend.VPython.graphicalrobot import \
-    GraphicalRobot
-from roboticstoolbox.backend.VPython.common_functions import \
-    close_localhost_session
+GraphicsCanvas3D = None
+GraphicsCanvas2D = None
+GraphicalRobot = None
+close_localhost_session = None
+
+
+def _imports():
+    global GraphicsCanvas3D
+    global GraphicsCanvas2D
+    global GraphicalRobot
+    global close_localhost_session
+
+    try:
+        canvas = importlib.import_module(
+            'roboticstoolbox.backend.VPython.canvas')
+        GraphicsCanvas3D = canvas.GraphicsCanvas3D
+        GraphicsCanvas2D = canvas.GraphicsCanvas2D
+
+        graphicalrobot = importlib.import_module(
+            'roboticstoolbox.backend.VPython.graphicalrobot')
+        GraphicalRobot = graphicalrobot.GraphicalRobot
+
+        common_functions = importlib.import_module(
+            'roboticstoolbox.backend.VPython.common_functions')
+        close_localhost_session = common_functions.close_localhost_session
+
+    except ImportError:
+        print(
+            '\nYou must install the VPython component of the toolbox, do: \n'
+            'pip install roboticstoolbox[vpython]\n\n')
 
 
-class VPython(Connector):
+class VPython(Connector):  # pragma nocover
     """
     Graphical backend using VPython
 
     VPython is a Python API that connects to a JavaScript/WebGL 3D graphics
-    engine in a browser tab.  It supports many 3D graphical primitives including
-    meshes, boxes, ellipsoids and lines. It can not render in full color.
+    engine in a browser tab.  It supports many 3D graphical primitives
+    including meshes, boxes, ellipsoids and lines. It can not render in
+    full color.
 
     Example:
 
@@ -41,7 +66,7 @@ class VPython(Connector):
     :references:
 
         - https://vpython.org
-        
+
     """
     # TODO be able to add ellipsoids (vellipse, fellipse)
     # TODO be able add lines (for end-effector paths)
@@ -53,14 +78,19 @@ def __init__(self):
         """
         super(VPython, self).__init__()
 
+        _imports()
+
         # Init vars
         self.canvases = []
-        self.canvas_settings = []  # 2D array of [is_3d, height, width, title, caption, grid] per canvas
+        # 2D array of [is_3d, height, width, title, caption, grid] per canvas
+        self.canvas_settings = []
         self.robots = []
 
         self._create_empty_session()
 
-    def launch(self, is_3d=True, height=500, width=888, title='', caption='', grid=True):
+    def launch(
+            self, is_3d=True, height=500, width=888,
+            title='', caption='', grid=True):
         """
         Launch a graphical backend in a browser tab
 
@@ -71,13 +101,16 @@ def launch(self, is_3d=True, height=500, width=888, title='', caption='', grid=T
 
         super().launch()
 
-        self.canvas_settings.append([is_3d, height, width, title, caption, grid])
+        self.canvas_settings.append(
+            [is_3d, height, width, title, caption, grid])
 
         # Create the canvas with the given information
         if is_3d:
-            self.canvases.append(GraphicsCanvas3D(height, width, title, caption, grid))
+            self.canvases.append(
+                GraphicsCanvas3D(height, width, title, caption, grid))
         else:
-            self.canvases.append(GraphicsCanvas2D(height, width, title, caption, grid))
+            self.canvases.append(
+                GraphicsCanvas2D(height, width, title, caption, grid))
 
     def step(self, id, q=None, fig_num=0):
         """
@@ -88,41 +121,44 @@ def step(self, id, q=None, fig_num=0):
         :type id: :class:`~roboticstoolbox.robot.DHRobot.DHRobot`,
             :class:`roboticstoolbox.backend.VPython.graphics_robot.GraphicalRobot`
         :param q: The joint angles/configuration of the robot (Optional, if not
-            supplied will use the stored q values). 
-        :type q: float ndarray(n) 
-        :param fig_num: The canvas index to delete the robot from, defaults to the
-            initial one 
-        :type fig_num: int, optional 
+            supplied will use the stored q values).
+        :type q: float ndarray(n)
+        :param fig_num: The canvas index to delete the robot from, defaults to
+            the initial one
+        :type fig_num: int, optional
         :raises ValueError: Figure number must be between 0 and total number of
-            canvases 
+            canvases
         :raises TypeError: Input must be a DHLink or GraphicalRobot
 
         ``env.step(args)`` triggers an update of the 3D scene in the browser
         window referenced by ``env``.
 
-        .. note:: 
+        .. note::
 
             - Each robot in the scene is updated based on
               their control type (position, velocity, acceleration, or torque).
             - Upon acting, the other three of the four control types will be
-              updated in the internal state of the robot object. 
-            - The control type is defined by the robot object, and not all robot
-              objects support all control types.
+              updated in the internal state of the robot object.
+            - The control type is defined by the robot object, and not all
+              robot objects support all control types.
             - Execution is blocked for the specified interval
 
         """
 
         super().step()
 
         if fig_num < 0 or fig_num >= len(self.canvases):
-            raise ValueError("Figure number must be between 0 and total number of canvases")
+            raise ValueError(
+                "Figure number must be between 0 and total number of canvases")
 
         # If DHRobot given
         if isinstance(id, r.Robot):
             robot = None
             # Find first occurrence of it that is in the correct canvas
             for i in range(len(self.robots)):
-                if self.robots[i].robot is id and self.canvases[fig_num].is_robot_in_canvas(self.robots[i]):
+                if self.robots[i].robot is id and \
+                        self.canvases[fig_num].is_robot_in_canvas(
+                                                        self.robots[i]):
                     robot = self.robots[i]
                     break
             if robot is None:
@@ -138,7 +174,9 @@ def step(self, id, q=None, fig_num=0):
                 id.set_joint_poses(poses)
         # Else
         else:
-            raise TypeError("Input must be a Robot (or subclass) or GraphicalRobot, given {0}".format(type(id)))
+            raise TypeError(
+                "Input must be a Robot (or subclass) or "
+                "GraphicalRobot, given {0}".format(type(id)))
 
     def reset(self):
         """
@@ -168,9 +206,13 @@ def reset(self):
             for settings in self.canvas_settings:
                 # Create the canvas with the given information
                 if settings[0]:
-                    self.canvases.append(GraphicsCanvas3D(settings[1], settings[2], settings[3], settings[4], settings[5]))
+                    self.canvases.append(GraphicsCanvas3D(
+                        settings[1], settings[2], settings[3],
+                        settings[4], settings[5]))
                 else:
-                    self.canvases.append(GraphicsCanvas2D(settings[1], settings[2], settings[3], settings[4], settings[5]))
+                    self.canvases.append(GraphicsCanvas2D(
+                        settings[1], settings[2], settings[3],
+                        settings[4], settings[5]))
 
     def restart(self):
         """
@@ -184,16 +226,6 @@ def restart(self):
 
         super().restart()
 
-        # self.close()
-        # self._create_empty_session()
-        # for settings in self.canvas_settings:
-        #     # Create the canvas with the given information
-        #     if settings[0]:
-        #         self.canvases.append(GraphicsCanvas3D(settings[1], settings[2], settings[3], settings[4], settings[5]))
-        #     else:
-        #         self.canvases.append(GraphicsCanvas2D(settings[1], settings[2], settings[3], settings[4], settings[5]))
-
-        # Program on close terminates execution, so just run reset
         self.reset()
 
     def close(self):
@@ -222,21 +254,23 @@ def add(self, fig_num, name, dhrobot):
         """
         Add a robot to the graphical scene
 
-        :param fig_num: The canvas number to place the robot in 
+        :param fig_num: The canvas number to place the robot in
         :type fig_num: int
-        :param name: The name of the robot 
-        :type name: `str` 
-        :param dhrobot: The ``DHRobot`` object (if applicable) 
-        :type dhrobot: class:`~roboticstoolbox.robot.DHRobot.DHRobot`, None 
-        :raises ValueError: Figure number must be between 0 and number of figures created
+        :param name: The name of the robot
+        :type name: `str`
+        :param dhrobot: The ``DHRobot`` object (if applicable)
+        :type dhrobot: class:`~roboticstoolbox.robot.DHRobot.DHRobot`, None
+        :raises ValueError: Figure number must be between 0 and number of
+            figures created
         :return: object id within visualizer
         :rtype: int
 
-        ``id = env.add(robot)`` adds the ``robot`` to the graphical environment.
+        ``id = env.add(robot)`` adds the ``robot`` to the graphical
+            environment.
 
         .. note::
 
-            - ``robot`` must be of an appropriate class. 
+            - ``robot`` must be of an appropriate class.
             - Adds the robot object to a list of robots which will be updated
               when the ``step()`` method is called.
 
@@ -251,42 +285,48 @@ def add(self, fig_num, name, dhrobot):
 
         # Sanity check input
         if fig_num < 0 or fig_num > len(self.canvases) - 1:
-            raise ValueError("Figure number must be between 0 and number of figures created")
+            raise ValueError(
+                "Figure number must be between 0 and number "
+                "of figures created")
 
         # Add robot to canvas
-        self.robots.append(GraphicalRobot(self.canvases[fig_num], name, dhrobot))
+        self.robots.append(
+            GraphicalRobot(self.canvases[fig_num], name, dhrobot))
         # self.canvases[fig_num].add_robot(self.robots[len(self.robots)-1])
 
     def remove(self, id, fig_num=0):
         """
         Remove a robot to the graphical scene
 
-        :param id: The id of the robot to remove. Can be either the DHLink or 
+        :param id: The id of the robot to remove. Can be either the DHLink or
             GraphicalRobot
         :type id: class:`~roboticstoolbox.robot.DHRobot.DHRobot`,
                   class:`roboticstoolbox.backend.VPython.graphics_robot.GraphicalRobot`
         :param fig_num: The canvas index to delete the robot from, defaults to
              the initial one
         :type fig_num: int, optional
-        :raises ValueError: Figure number must be between 0 and total number 
+        :raises ValueError: Figure number must be between 0 and total number
             of canvases
         :raises TypeError: Input must be a DHLink or GraphicalRobot
 
-        ``env.remove(robot)`` removes the ``robot`` from the graphical environment.
+        ``env.remove(robot)`` removes the ``robot`` from the graphical
+            environment.
 
         """
 
         super().remove()
 
         if fig_num < 0 or fig_num >= len(self.canvases):
-            raise ValueError("Figure number must be between 0 and total number of canvases")
+            raise ValueError(
+                "Figure number must be between 0 and total number of canvases")
 
         # If DHLink given
         if isinstance(id, DHLink):
             robot = None
             # Find first occurrence of it that is in the correct canvas
             for i in range(len(self.robots)):
-                if self.robots[i].seriallink.equal(id) and self.canvases[fig_num].is_robot_in(self.robots[i]):
+                if self.robots[i].seriallink.equal(id) and \
+                        self.canvases[fig_num].is_robot_in(self.robots[i]):
                     robot = self.robots[i]
                     break
             if robot is None: