Try replaceing github/petercorke with github/bdaiinstitute

Author: myeatman-bdai

.github/workflows/sphinx.yml

@@ -17,7 +17,7 @@ jobs:
       run: |
         python -m pip install --upgrade pip
         pip install .[dev,docs]
-        pip install git+https://github.com/petercorke/sphinx-autorun.git
+        pip install git+https://github.com/bdaiinstitute/sphinx-autorun.git
         pip install sympy
         sudo apt-get install graphviz
     - name: Build docs
@@ -29,7 +29,7 @@ jobs:
         cd ../
     - name: Commit documentation changes
       run: |
-        git clone https://github.com/petercorke/spatialmath-python.git --branch gh-pages --single-branch gh-pages
+        git clone https://github.com/bdaiinstitute/spatialmath-python.git --branch gh-pages --single-branch gh-pages
         cp -r docs/build/html/* gh-pages/
         cd gh-pages
         git config --local user.email "[email protected]"

README.md

@@ -1,6 +1,6 @@
 # Spatial Maths for Python
 
-[![A Python Robotics Package](https://raw.githubusercontent.com/petercorke/robotics-toolbox-python/master/.github/svg/py_collection.min.svg)](https://github.com/petercorke/robotics-toolbox-python)
+[![A Python Robotics Package](https://raw.githubusercontent.com/petercorke/robotics-toolbox-python/master/.github/svg/py_collection.min.svg)](https://github.com/bdaiinstitute/robotics-toolbox-python)
 [![QUT Centre for Robotics Open Source](https://github.com/qcr/qcr.github.io/raw/master/misc/badge.svg)](https://qcr.github.io)
 
 [![PyPI version](https://badge.fury.io/py/spatialmath-python.svg)](https://badge.fury.io/py/spatialmath-python)
@@ -20,7 +20,7 @@
 <td style="border:0px">
 <img src="https://github.com/bdaiinstitute/spatialmath-python/raw/master/docs/figs/CartesianSnakes_LogoW.png" width="200"></td>
 <td style="border:0px">
-A Python implementation of the <a href="https://github.com/petercorke/spatial-math">Spatial Math Toolbox for MATLAB<sup>&reg;</sup></a>
+A Python implementation of the <a href="https://github.com/bdaiinstitute/spatial-math">Spatial Math Toolbox for MATLAB<sup>&reg;</sup></a>
 <ul>
 <li><a href="https://github.com/bdaiinstitute/spatialmath-python">GitHub repository </a></li>
 <li><a href="https://bdaiinstitute.github.io/spatialmath-python">Documentation</a></li>
@@ -45,8 +45,8 @@ space:
 | ------------ | ---------------- | -------- |
 | pose         | ``SE3`` ``Twist3`` ``UnitDualQuaternion``   |   ``SE2`` ``Twist2`` |
 | orientation  | ``SO3`` ``UnitQuaternion`` |            ``SO2``  |
-                
-                
+
+
 More specifically:
 
  * `SE3` matrices belonging to the group $\mathbf{SE}(3)$ for position and orientation (pose) in 3-dimensions
@@ -80,7 +80,7 @@ The class, method and functions names largely mirror those of the MATLAB toolbox
 
 # Citing
 
-Check out our ICRA 2021 paper on [IEEE Xplore](https://ieeexplore.ieee.org/document/9561366) or get the PDF from [Peter's website](https://bit.ly/icra_rtb).  This describes the [Robotics Toolbox for Python](https://github.com/petercorke/robotics-toolbox-python) as well Spatial Maths.
+Check out our ICRA 2021 paper on [IEEE Xplore](https://ieeexplore.ieee.org/document/9561366) or get the PDF from [Peter's website](https://bit.ly/icra_rtb).  This describes the [Robotics Toolbox for Python](https://github.com/bdaiinstitute/robotics-toolbox-python) as well Spatial Maths.
 
 If the toolbox helped you in your research, please cite
 
@@ -160,26 +160,26 @@ For example, to create an object representing a rotation of 0.3 radians about th
 >>> from spatialmath import SO3, SE3
 >>> R1 = SO3.Rx(0.3)
 >>> R1
-   1         0         0          
-   0         0.955336 -0.29552    
-   0         0.29552   0.955336         
+   1         0         0
+   0         0.955336 -0.29552
+   0         0.29552   0.955336
 ```
 while a rotation of 30 deg about the z-axis is
 
 ```python
 >>> R2 = SO3.Rz(30, 'deg')
 >>> R2
-   0.866025 -0.5       0          
-   0.5       0.866025  0          
-   0         0         1    
+   0.866025 -0.5       0
+   0.5       0.866025  0
+   0         0         1
 ```
-and the composition of these two rotations is 
+and the composition of these two rotations is
 
 ```python
 >>> R = R1 * R2
-   0.866025 -0.5       0          
-   0.433013  0.75     -0.5        
-   0.25      0.433013  0.866025 
+   0.866025 -0.5       0
+   0.433013  0.75     -0.5
+   0.25      0.433013  0.866025
 ```
 
 We can find the corresponding Euler angles (in radians)
@@ -198,16 +198,16 @@ Frequently in robotics we want a sequence, a trajectory, of rotation matrices or
 >>> len(R)
  3
 >>> R[1]
-   1         0         0          
-   0         0.955336 -0.29552    
-   0         0.29552   0.955336             
+   1         0         0
+   0         0.955336 -0.29552
+   0         0.29552   0.955336
 ```
 and this can be used in `for` loops and list comprehensions.
 
 An alternative way of constructing this would be (`R1`, `R2` defined above)
 
 ```python
->>> R = SO3( [ SO3(), R1, R2 ] )       
+>>> R = SO3( [ SO3(), R1, R2 ] )
 >>> len(R)
  3
 ```
@@ -233,7 +233,7 @@ will produce a result where each element is the product of each element of the l
 Similarly
 
 ```python
->>> A = SO3.Ry(0.5) * R 
+>>> A = SO3.Ry(0.5) * R
 >>> len(R)
  32
 ```
@@ -242,7 +242,7 @@ will produce a result where each element is the product of the left-hand side wi
 Finally
 
 ```python
->>> A = R * R 
+>>> A = R * R
 >>> len(R)
  32
 ```
@@ -267,10 +267,10 @@ We can print and plot these objects as well
 ```
 >>> T = SE3(1,2,3) * SE3.Rx(30, 'deg')
 >>> T.print()
-   1         0         0         1          
-   0         0.866025 -0.5       2          
-   0         0.5       0.866025  3          
-   0         0         0         1          
+   1         0         0         1
+   0         0.866025 -0.5       2
+   0         0.5       0.866025  3
+   0         0         0         1
 
 >>> T.printline()
 t =        1,        2,        3; rpy/zyx =       30,        0,        0 deg
@@ -339,7 +339,7 @@ array([[1., 0., 1.],
        [0., 0., 1.]])
 
 transl2( (1,2) )
-Out[444]: 
+Out[444]:
 array([[1., 0., 1.],
        [0., 1., 2.],
        [0., 0., 1.]])
@@ -349,7 +349,7 @@ array([[1., 0., 1.],
 
 ```
 transl2( np.array([1,2]) )
-Out[445]: 
+Out[445]:
 array([[1., 0., 1.],
        [0., 1., 2.],
        [0., 0., 1.]])
@@ -436,7 +436,7 @@ Out[259]: int
 
 a = T[1,1]
 a
-Out[256]: 
+Out[256]:
 cos(theta)
 type(a)
 Out[255]: cos
@@ -447,6 +447,6 @@ Similarly when we assign an element or slice of the symbolic matrix to a numeric
 
 ## History & Contributors
 
-This package was originally created by [Peter Corke](https://github.com/petercorke) and [Jesse Haviland](https://github.com/jhavl) and was inspired by the [Spatial Math Toolbox for MATLAB](https://github.com/petercorke/spatialmath-matlab).  It supports the textbook [Robotics, Vision & Control in Python 3e](https://github.com/petercorke/RVC3-python).
+This package was originally created by [Peter Corke](https://github.com/bdaiinstitute) and [Jesse Haviland](https://github.com/jhavl) and was inspired by the [Spatial Math Toolbox for MATLAB](https://github.com/bdaiinstitute/spatialmath-matlab).  It supports the textbook [Robotics, Vision & Control in Python 3e](https://github.com/bdaiinstitute/RVC3-python).
 
 The package is now a collaboration with [Boston Dynamics AI Institute](https://theaiinstitute.com/).

docs/source/intro.rst

@@ -4,10 +4,10 @@ Introduction
 ************
 
 
-Spatial maths capability underpins all of robotics and robotic vision. 
-It provides the means to describe the relative position and orientation of objects in 2D or 3D space.  
+Spatial maths capability underpins all of robotics and robotic vision.
+It provides the means to describe the relative position and orientation of objects in 2D or 3D space.
 This package provides Python classes and functions to represent, print, plot, manipulate and covert between such representations.
-This includes relevant mathematical objects such as rotation matrices :math:`\mat{R} \in \SO{2}, \SO{3}`, 
+This includes relevant mathematical objects such as rotation matrices :math:`\mat{R} \in \SO{2}, \SO{3}`,
 homogeneous transformation matrices :math:`\mat{T} \in \SE{2}, \SE{3}`, unit quaternions :math:`\q \in \mathrm{S}^3`,
 and twists :math:`S \in \se{2}, \se{3}`.
 
@@ -27,7 +27,7 @@ which results in a NumPy :math:`4 \times 4` array that belongs to the group
     >>> from spatialmath import *
     >>> T = SE3.Rx(30, 'deg')
     >>> type(T)
-    >>> print(T)                
+    >>> print(T)
 
 which is *internally* represented as a :math:`4 \times 4` NumPy array.
 
@@ -81,7 +81,7 @@ Group                             Name                            Class
 ================================  ==============================  ======================
 
 
-In addition to the merits of classes outlined above, classes ensure that the numerical value is always valid because the 
+In addition to the merits of classes outlined above, classes ensure that the numerical value is always valid because the
 constraints (eg. orthogonality, unit norm) are enforced when the object is constructed.  For example::
 
   >>> SE3(np.zeros((4,4)))
@@ -90,7 +90,7 @@ constraints (eg. orthogonality, unit norm) are enforced when the object is const
     .
   AssertionError: array must have valid value for the class
 
-Type safety and type validity are particularly important when we deal with a sequence of values.  
+Type safety and type validity are particularly important when we deal with a sequence of values.
 In robotics we frequently deal with a multiplicity of objects (poses, cameras), or a trajectory of
 objects moving over time.
 However a list of these items, for example::
@@ -114,7 +114,7 @@ The Spatial Math package give these classes list *super powers* so that, for exa
     >>> from spatialmath import *
     >>> X = SE3.Rx([0, 0.2, 0.4, 0.6])
     >>> len(X)
-    >>> print(X[1])          
+    >>> print(X[1])
 
 
 The classes form a rich hierarchy
@@ -127,7 +127,7 @@ The classes form a rich hierarchy
 Ultimately they all inherit from ``collections.UserList`` and have all the functionality of Python lists, and this is discussed further in
 section :ref:`list-powers`
 The pose objects are a list subclass so we can index it or slice it as we
-would a list, but the result always belongs to the class it was sliced from.  
+would a list, but the result always belongs to the class it was sliced from.
 
 
 Operators for pose objects
@@ -176,9 +176,9 @@ Vector transformation
 ^^^^^^^^^^^^^^^^^^^^^
 
 
-The classes ``SE3``, ``SO3``, ``SE2``, ``SO2`` and ``UnitQuaternion`` support vector transformation when 
+The classes ``SE3``, ``SO3``, ``SE2``, ``SO2`` and ``UnitQuaternion`` support vector transformation when
 premultiplying a vector (or a set of vectors columnwise in a NumPy array) using the ``*`` operator.
-This is either rotation about the origin (for ``SO3``, ``SO2`` and ``UnitQuaternion``) or rotation and translation (``SE3``, ``SE2``).  
+This is either rotation about the origin (for ``SO3``, ``SO2`` and ``UnitQuaternion``) or rotation and translation (``SE3``, ``SE2``).
 The implementation depends on the class of the object involved:
 
 - for ``UnitQuaternion`` this is performed directly using Hamilton products
@@ -238,7 +238,7 @@ Compare this to the unit quaternion case:
     >>> 2 * q
 
 Noting that unit quaternions are denoted by double angle bracket delimiters of their vector part,
-whereas a general quaternion uses single angle brackets.  The product of a general quaternion and a 
+whereas a general quaternion uses single angle brackets.  The product of a general quaternion and a
 unit quaternion is always a general quaternion.
 
 
@@ -386,7 +386,7 @@ a Python list
     >>> len(R)
     >>> R = SO3.Rx(np.arange(0, 2*np.pi, 0.2))
     >>> len(R)
-    >>> R[0]  
+    >>> R[0]
     >>> R[-1]
     >>> R[2:4]
 
@@ -404,12 +404,12 @@ In particular it supports iteration which allows looping and comprehensions:
     >>> eul = [x.eul() for x in R]
     >>> len(eul)
     >>> eul[10]
-  
+
 Useful functions that be used on such objects include
 
-=============  ================================================ 
+=============  ================================================
 Method              Operation
-=============  ================================================ 
+=============  ================================================
 ``clear``       Clear all elements, object now has zero length
 ``append``      Append a single element
 ``del``
@@ -421,7 +421,7 @@ Method              Operation
 ``pop``         Remove first element and return it
 ``slice``       Index from a slice object
 ``zip``         Iterate over the elments
-=============  ================================================ 
+=============  ================================================
 
 
 Vectorization
@@ -444,7 +444,7 @@ the lengths of the operands and the results are given by
 ======   ======   ======  ========================
      operands           results
 ---------------   --------------------------------
-len(X)   len(Y)   len(Z)     results         
+len(X)   len(Y)   len(Z)     results
 ======   ======   ======  ========================
   1        1        1       Z    = X op Y
   1        M        M       Z[i] = X op Y[i]
@@ -523,34 +523,34 @@ Spatial object       equivalent class   NumPy ndarray.shape
 n/a                  Quaternion            (4,)
 =================    ================   ===================
 
-.. note:: ``SpatialVector`` and ``Line3`` objects have no equivalent in the 
+.. note:: ``SpatialVector`` and ``Line3`` objects have no equivalent in the
   ``base`` package.
 
 Inputs to functions in this package are either floats, lists, tuples or
-numpy.ndarray objects describing vectors or arrays.  
+numpy.ndarray objects describing vectors or arrays.
 
 NumPy arrays have a shape described by a shape tuple which is a list of the
 dimensions.  Typically all ``ndarray`` **vectors** have the shape ``(N,)``, that is,
 they have only one dimension.  The ``@`` product of an ``(M,N)`` array and a ``(N,)``
-vector is an ``(M,)`` vector.  
+vector is an ``(M,)`` vector.
 
 A numpy column vector has shape ``(N,1)`` and a row vector
-has shape ``(1,N)`` but functions also accept row ``(1,N)``  and column ``(N,1)`` 
-where a vector argument is required.  
+has shape ``(1,N)`` but functions also accept row ``(1,N)``  and column ``(N,1)``
+where a vector argument is required.
 
 .. warning:: For a user transitioning from MATLAB the most significant
   differences are:
     - the use of 1D arrays -- all MATLAB arrays have two dimensions,
       even if one of them is equal to one.
     - Iterating over a 1D NumPy array (N,) returns consecutive elements
-    - Iterating over a 2D NumPy array is done by row, not columns as in MATLAB.  
+    - Iterating over a 2D NumPy array is done by row, not columns as in MATLAB.
     - Iterating over a row vector ``(1,N)`` returns the entire row
     - Iterating a column vector ``(N,1)`` returns consecutive elements (rows).
 
 .. note::
   - Functions that require vector can be passed a list, tuple or numpy.ndarray
     for a vector -- described in the documentation as being of type
-    *array_like*. 
+    *array_like*.
   - This toolbox documentation refers to NumPy arrays succinctly as:
 
     - ``ndarray(N)`` for a 1D array of length ``N``
@@ -633,7 +633,7 @@ If ``matplotlib`` is installed then we can add 2D coordinate frames to a figure
     >>> trplot2( transl2(4, 3)@trot2(math.pi/3), color='green', frame='c')
     >>> plt.grid(True)
 
-.. figure:: ../figs/transforms2d.png 
+.. figure:: ../figs/transforms2d.png
    :align: center
 
    Output of ``trplot2``
@@ -689,7 +689,7 @@ matrix
     >>> a
     >>> type(a)
     >>> a = T[1,1]
-    >>> a 
+    >>> a
     >>> type(a)
 
 We see that the symbolic constants have been converted back to Python numeric
@@ -718,9 +718,9 @@ Relationship to MATLAB tools
 ----------------------------
 
 This package replicates, as much as possible, the functionality of the `Spatial
-Math Toolbox  <https://github.com/petercorke/spatial-math>`__ for MATLAB®
+Math Toolbox  <https://github.com/bdaiinstitute/spatial-math>`__ for MATLAB®
 which underpins the `Robotics Toolbox
-<https://github.com/petercorke/robotics-toolbox-matlab>`__ for MATLAB®. It
+<https://github.com/bdaiinstitute/robotics-toolbox-matlab>`__ for MATLAB®. It
 comprises:
 
 * the *classic* functions (which date back to the origin of the Robotics Toolbox
@@ -730,7 +730,7 @@ comprises:
     >>> from spatialmath.base import rotx, trotx
 
   and works with NumPy arrays.  This package also includes a set of functions,
-  not present in the MATLAB version, to handle quaternions, unit-quaternions 
+  not present in the MATLAB version, to handle quaternions, unit-quaternions
   which are represented as 4-element NumPy arrays, and twists.
 * the classes (which appeared in Robotics Toolbox for MATLAB release 10 in 2017) such as ``SE3``, ``UnitQuaternion`` etc.  The only significant difference
   is that the MATLAB ``Twist`` class is now called ``Twist3``.
@@ -766,6 +766,3 @@ which has the familiar *classic* functions like ``rotx`` and ``rpy2r`` available
     R2 = rpy2r(0.1, 0.2, 0.3)
 
     T = SE3(1, 2, 3)
-
-
-

tests/base/test_quaternions.py

@@ -1,5 +1,5 @@
 # This file is part of the SpatialMath toolbox for Python
-# https://github.com/petercorke/spatialmath-python
+# https://github.com/bdaiinstitute/spatialmath-python
 #
 # MIT License
 #