psychopy 2024.2.5__py3-none-any.whl → 2025.1.1__py3-none-any.whl

psychopy/tools/mathtools.py

@@ -1,80 +1,829 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-# Various math functions for working with vectors, matrices, and quaternions.
-#
+"""Various math functions for working with vectors, matrices, and quaternions.
+"""
 
 # Part of the PsychoPy library
-# Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2024 Open Science Tools Ltd.
+# Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2025 Open Science Tools Ltd.
 # Distributed under the terms of the GNU General Public License (GPL).
 
-__all__ = ['normalize',
-           'lerp',
-           'slerp',
-           'multQuat',
-           'quatFromAxisAngle',
-           'quatToMatrix',
-           'scaleMatrix',
-           'rotationMatrix',
-           'transform',
-           'translationMatrix',
-           'concatenate',
-           'applyMatrix',
-           'invertQuat',
-           'quatToAxisAngle',
-           'posOriToMatrix',
-           'applyQuat',
-           'orthogonalize',
-           'reflect',
-           'cross',
-           'distance',
-           'dot',
-           'quatMagnitude',
-           'length',
-           'project',
-           'bisector',
-           'surfaceNormal',
-           'invertMatrix',
-           'angleTo',
-           'surfaceBitangent',
-           'surfaceTangent',
-           'vertexNormal',
-           'isOrthogonal',
-           'isAffine',
-           'perp',
-           'ortho3Dto2D',
-           'intersectRayPlane',
-           'matrixToQuat',
-           'lensCorrection',
-           'matrixFromEulerAngles',
-           'alignTo',
-           'quatYawPitchRoll',
-           'intersectRaySphere',
-           'intersectRayAABB',
-           'intersectRayOBB',
-           'intersectRayTriangle',
-           'scale',
-           'multMatrix',
-           'normalMatrix',
-           'fitBBox',
-           'computeBBoxCorners',
-           'zeroFix',
-           'accumQuat',
-           'fixTangentHandedness',
-           'articulate',
-           'forwardProject',
-           'reverseProject',
-           'lensCorrectionSpherical']
+__all__ = [
+    'VEC_AXES',  # constants
+    'VEC_AXIS_FORWARD',
+    'VEC_AXIS_BACKWARD',
+    'VEC_AXIS_UP',
+    'VEC_AXIS_DOWN',
+    'VEC_AXIS_RIGHT',
+    'VEC_AXIS_LEFT',
+    'VEC_AXIS_POS_X',
+    'VEC_AXIS_NEG_X',
+    'VEC_AXIS_POS_Y',
+    'VEC_AXIS_NEG_Y',
+    'VEC_AXIS_POS_Z',
+    'VEC_AXIS_NEG_Z',
+    'RigidBodyPose',  # rigid body pose class
+    'BoundingBox',
+    'length',  # vector functions
+    'normalize',
+    'orthogonalize',
+    'reflect',
+    'dot',
+    'cross',
+    'project',
+    'lerp',
+    'distance',
+    'perp',
+    'bisector',
+    'angleTo',
+    'sortClockwise',
+    'surfaceNormal',
+    'surfaceBitangent',
+    'surfaceTangent',
+    'vertexNormal',
+    'fixTangentHandedness',
+    'fitBBox',
+    'computeBBoxCorners',
+    'intersectRayPlane',
+    'intersectRaySphere',
+    'intersectRayAABB',
+    'intersectRayOBB',
+    'intersectRayTriangle',
+    'ortho3Dto2D',
+    'articulate',
+    'slerp',  # quaternion functions
+    'quatToAxisAngle',
+    'quatFromAxisAngle',
+    'quatYawPitchRoll',
+    'quatMagnitude',
+    'multQuat',
+    'invertQuat',
+    'applyQuat',
+    'accumQuat',
+    'alignTo',
+    'matrixToQuat',
+    'identityMatrix',  # matrix functions
+    'quatToMatrix',
+    'scaleMatrix',
+    'rotationMatrix',
+    'translationMatrix',
+    'invertMatrix',
+    'multMatrix',
+    'concatenate',
+    'matrixFromEulerAngles',
+    'isOrthogonal',
+    'isAffine',
+    'applyMatrix',
+    'posOriToMatrix',
+    'transform',
+    'scale',
+    'normalMatrix',
+    'forwardProject',
+    'reverseProject',
+    'lookAt',
+    'zeroFix',  # misc functions
+    'lensCorrection',
+    'lensCorrectionSpherical',
+    'infrange',
+    'setDefaultPrecision'
+]
 
 
 import numpy as np
 import functools
 import itertools
 
+VEC_AXES = {  # mapping of axis names to vectors
+    '+x': (1, 0, 0), '-x': (-1, 0, 0),
+    '+y': (0, 1, 0), '-y': (0, -1, 0),
+    '+z': (0, 0, 1), '-z': (0, 0, -1)}
+
+# vectors for common axes
+VEC_AXIS_BACKWARD = VEC_AXIS_POS_Z = VEC_AXES['+z']
+VEC_AXIS_FORWARD = VEC_AXIS_NEG_Z = VEC_AXES['-z']
+VEC_AXIS_UP = VEC_AXIS_POS_Y = VEC_AXES['+y']
+VEC_AXIS_DOWN = VEC_AXIS_NEG_Y = VEC_AXES['-y']
+VEC_AXIS_RIGHT = VEC_AXIS_POS_X = VEC_AXES['+x']
+VEC_AXIS_LEFT = VEC_AXIS_NEG_X = VEC_AXES['-x']
+
+DEFAULT_DTYPE = float
+
+
+def setDefaultPrecision(dtype='float64'):
+    """Set the default precision for math functions.
+
+    Once set, all math functions in this module will use the specified data type 
+    for computations in successive calls. This is useful when you want to ensure
+    a specific precision for all math operations.
+
+    Parameters
+    ----------
+    dtype : dtype or str
+        Data type for computations can either be 'float32' or 'float64'.
+
+    """
+    global DEFAULT_DTYPE
+    DEFAULT_DTYPE = np.dtype(dtype).type
+    
+
+# ------------------------------------------------------------------------------
+# Classes for working with rigid body poses
+#
+
+class RigidBodyPose:
+    """Class for representing rigid body poses.
+
+    This class is an abstract representation of a rigid body pose, where the
+    position of the body in a scene is represented by a vector/coordinate and
+    the orientation with a quaternion. Pose can be manipulated and interacted
+    with using class methods and attributes. Rigid body poses assume a
+    right-handed coordinate system (-Z is forward and +Y is up).
+
+    Poses can be converted to 4x4 transformation matrices with `getModelMatrix`.
+    One can use these matrices when rendering to transform the vertices of a
+    model associated with the pose by passing them to OpenGL. Matrices are
+    cached internally to avoid recomputing them if `pos` and `ori` attributes
+    have not been updated.
+
+    Operators `*` and `~` can be used on `RigidBodyPose` objects to combine and
+    invert poses. For instance, you can multiply (`*`) poses to get a new pose
+    which is the combination of both orientations and translations by::
+
+        newPose = rb1 * rb2
+
+    Likewise, a pose can be inverted by using the `~` operator::
+
+        invPose = ~rb
+
+    Multiplying a pose by its inverse will result in an identity pose with no
+    translation and default orientation where `pos=[0, 0, 0]` and
+    `ori=[0, 0, 0, 1]`::
+
+        identityPose = ~rb * rb
+
+    Warnings
+    --------
+    This class is experimental and may result in undefined behavior.
+
+    """
+    def __init__(self, pos=(0., 0., 0.), ori=(0., 0., 0., 1.), dtype=None):
+        """
+        Parameters
+        ----------
+        pos : array_like
+            Position vector `[x, y, z]` for the origin of the rigid body.
+        ori : array_like
+            Orientation quaternion `[x, y, z, w]` where `x`, `y`, `z` are
+            imaginary and `w` is real.
+        dtype : dtype or str, optional
+            Data type for computations can either be 'float32' or 'float64'.
+            Default is `None` which uses the default data configured by
+            `setDefaultPrecision`.
+
+        """
+        # set the data type for computations
+        self._dtype = \
+            np.dtype(dtype).type if dtype is not None else DEFAULT_DTYPE
+
+        # position and orientation
+        self._pos = np.ascontiguousarray(pos, dtype=self.dtype)
+        self._ori = np.ascontiguousarray(ori, dtype=self.dtype)
+
+        self._modelMatrix = posOriToMatrix(
+            self._pos, self._ori, dtype=self.dtype)
+
+        # computed only if needed
+        self._normalMatrix = np.zeros((4, 4), dtype=self.dtype, order='C')
+        self._invModelMatrix = np.zeros((4, 4), dtype=self.dtype, order='C')
+        self._viewMatrix = np.zeros((4, 4), dtype=self.dtype, order='C')
+        self._invViewMatrix = np.zeros((4, 4), dtype=self.dtype, order='C')
+
+        # additional useful vectors
+        self._at = np.zeros((3,), dtype=self.dtype, order='C')
+        self._up = np.zeros((3,), dtype=self.dtype, order='C')
+        self._viewAxes = np.array(  # cache for view matrix calculations
+            [VEC_AXIS_FORWARD, VEC_AXIS_UP], dtype=self.dtype, order='C')
+
+        # compute matrices only if `pos` and `ori` attributes have been updated,
+        # we track the state of the matrices with these flags
+        self._cacheFlags = {
+            'model': True,  # already computed
+            'imodel': False,
+            'normal': False,
+            'view': False,
+            'iview': False
+        }
+
+        self.pos = pos
+        self.ori = ori
+
+        self._bounds = None
+
+    def __repr__(self):
+        return 'RigidBodyPose(pos={}, ori={})'.format(self.pos, self.ori)
+
+    @property
+    def dtype(self):
+        """Data type used for computations and arrays (`numpy.dtype`).
+
+        Cannot be changed after object creation.
+
+        """
+        return self._dtype
+
+    @property
+    def bounds(self):
+        """Bounding box associated with this pose.
+        """
+        return self._bounds
+
+    @bounds.setter
+    def bounds(self, value):
+        self._bounds = value
+
+    @property
+    def pos(self):
+        """Position vector (X, Y, Z).
+        """
+        return self._pos
+
+    @pos.setter
+    def pos(self, value):
+        self._pos = np.ascontiguousarray(value, dtype=self.dtype)
+        self._cacheFlags = dict.fromkeys(self._cacheFlags.keys(), True)
+
+    @property
+    def ori(self):
+        """Orientation quaternion (X, Y, Z, W).
+        """
+        return self._ori
+
+    @ori.setter
+    def ori(self, value):
+        self._ori = np.ascontiguousarray(value, dtype=self.dtype)
+        self._cacheFlags = dict.fromkeys(self._cacheFlags.keys(), True)
+
+    @property
+    def posOri(self):
+        """The position (x, y, z) and orientation (x, y, z, w).
+        """
+        return self._pos, self._ori
+
+    @posOri.setter
+    def posOri(self, value):
+        self._pos = np.ascontiguousarray(value[0], dtype=self.dtype)
+        self._ori = np.ascontiguousarray(value[1], dtype=self.dtype)
+        self._cacheFlags = dict.fromkeys(self._cacheFlags.keys(), True)
+
+    @property
+    def at(self):
+        """Vector defining the forward direction (-Z) of this pose.
+        """
+        # matrix needs update, this need to be too
+        if self._cacheFlags['model']:  
+            self._at = applyQuat(
+                self.ori, self._viewAxes[0, :], out=self._at, dtype=self.dtype)
+
+        return self._at
+
+    @property
+    def up(self):
+        """Vector defining the up direction (+Y) of this pose.
+        """
+        if self._cacheFlags['model']:
+            self._up = applyQuat(
+                self.ori, self._viewAxes[1, :], out=self._up, dtype=self.dtype)
+
+        return self._up
+
+    def __mul__(self, other):
+        """Multiply two poses, combining them to get a new pose.
+        """
+        newOri = multQuat(self._ori, other.ori)
+        return RigidBodyPose(transform(other.pos, newOri, self._pos), newOri)
+
+    def __imul__(self, other):
+        """Inplace multiplication. Transforms this pose by another.
+        """
+        self._ori = multQuat(self._ori, other.ori)
+        self._pos = transform(other.pos, self._ori, self._pos)
+
+    def copy(self):
+        """Get a new `RigidBodyPose` object which copies the position and
+        orientation of this one. Copies are independent and do not reference
+        each others data.
+
+        Returns
+        -------
+        RigidBodyPose
+            Copy of this pose.
+
+        """
+        return RigidBodyPose(self._pos, self._ori)
+
+    def isEqual(self, other):
+        """Check if poses have similar orientation and position.
+
+        Parameters
+        ----------
+        other : `RigidBodyPose`
+            Other pose to compare.
+
+        Returns
+        -------
+        bool
+            Returns `True` is poses are effectively equal.
+
+        """
+        return np.isclose(self._pos, other.pos) and \
+            np.isclose(self._ori, other.ori)
+
+    def clear(self):
+        """Clear the pose, setting position and orientation to zero.
+        """
+        self._pos.fill(0.0)
+        self._ori[:3] = 0.0
+        self._ori[3] = 1.0
+        self._cacheFlags = dict.fromkeys(a.keys(), True)
+
+    def setIdentity(self):
+        """Clear rigid body transformations (alias for `clear`).
+        """
+        self.clear()
+
+    def getOriAxisAngle(self, degrees=True):
+        """Get the axis and angle of rotation for the rigid body. Converts the
+        orientation defined by the `ori` quaternion to and axis-angle
+        representation.
+
+        Parameters
+        ----------
+        degrees : bool, optional
+            Specify ``True`` if `angle` is in degrees, or else it will be
+            treated as radians. Default is ``True``.
+
+        Returns
+        -------
+        tuple
+            Axis [rx, ry, rz] and angle.
+
+        """
+        return quatToAxisAngle(self._ori, degrees, dtype=self.dtype)
+
+    def setOriAxisAngle(self, axis, angle, degrees=True):
+        """Set the orientation of the rigid body using an `axis` and
+        `angle`. This sets the quaternion at `ori`.
+
+        Parameters
+        ----------
+        axis : array_like
+            Axis of rotation [rx, ry, rz].
+        angle : float
+            Angle of rotation.
+        degrees : bool, optional
+            Specify ``True`` if `angle` is in degrees, or else it will be
+            treated as radians. Default is ``True``.
+
+        """
+        self.ori = quatFromAxisAngle(axis, angle, degrees, dtype=self.dtype)
+
+    def getYawPitchRoll(self, degrees=True):
+        """Get the yaw, pitch and roll angles for this pose relative to the -Z
+        world axis.
+
+        Parameters
+        ----------
+        degrees : bool, optional
+            Specify ``True`` if `angle` is in degrees, or else it will be
+            treated as radians. Default is ``True``.
+
+        """
+        return quatYawPitchRoll(self._ori, degrees, dtype=self.dtype)
+
+    @property
+    def modelMatrix(self):
+        """Pose as a 4x4 model matrix (read-only)."""
+        if not self._cacheFlags['model']:
+            return self._modelMatrix
+        else:
+            return self.getModelMatrix()
+
+    @property
+    def inverseModelMatrix(self):
+        """Inverse of the pose as a 4x4 model matrix (read-only)."""
+        if not self._cacheFlags['imodel']:
+            return self._invModelMatrix
+        else:
+            return self.getModelMatrix(inverse=True)
+
+    @property
+    def normalMatrix(self):
+        """The 4x4 normal transformation matrix (read-only)."""
+        if not self._cacheFlags['normal']:
+            return self._normalMatrix
+        else:
+            return self.getNormalMatrix()
+
+    @property
+    def viewMatrix(self):
+        """The 4x4 view matrix for this pose (read-only)."""
+        if not self._cacheFlags['view']:
+            return self._viewMatrix
+        else:
+            return self.getViewMatrix()
+
+    @property
+    def inverseViewMatrix(self):
+        """The inverse of the 4x4 view matrix for this pose (read-only)."""
+        if not self._cacheFlags['iview']:
+            return self._invViewMatrix
+        else:
+            return self.getViewMatrix(inverse=True)
+
+    def getNormalMatrix(self, out=None):
+        """Get the present normal matrix.
+
+        Parameters
+        ----------
+        out : ndarray or None
+            Optional 4x4 array to write values to. Values written are computed
+            using 32-bit float precision regardless of the data type of `out`.
+
+        Returns
+        -------
+        ndarray
+            4x4 normal transformation matrix.
+
+        """
+        if not self._cacheFlags['normal']:
+            return self._normalMatrix
+
+        self._normalMatrix[:, :] = np.linalg.inv(self.modelMatrix).T
+        self._cacheFlags['normal'] = False
+
+        if out is not None:
+            out[:, :] = self._normalMatrix[:, :]
+            return out
+
+        return self._normalMatrix
+
+    def getModelMatrix(self, inverse=False, out=None):
+        """Get the present rigid body transformation as a 4x4 matrix.
+
+        Matrices are computed only if the `pos` and `ori` attributes have been
+        updated since the last call to `getModelMatrix`. The returned matrix is
+        an `ndarray` and row-major.
+
+        Parameters
+        ----------
+        inverse : bool, optional
+            Return the inverse of the model matrix.
+        out : ndarray or None
+            Optional 4x4 array to write values to. Values written are computed
+            using 32-bit float precision regardless of the data type of `out`.
+
+        Returns
+        -------
+        ndarray
+            4x4 transformation matrix.
+
+        Examples
+        --------
+        Using a rigid body pose to transform something in OpenGL::
+
+            rb = RigidBodyPose((0, 0, -2))  # 2 meters away from origin
+
+            # Use `array2pointer` from `psychopy.tools.arraytools` to convert
+            # array to something OpenGL accepts.
+            mv = array2pointer(rb.modelMatrix)
+
+            # use the matrix to transform the scene
+            glMatrixMode(GL_MODELVIEW)
+            glPushMatrix()
+            glLoadIdentity()
+            glMultTransposeMatrixf(mv)
+
+            # draw the thing here ...
+
+            glPopMatrix()
+
+        """
+        if self._cacheFlags['model']:
+            self._modelMatrix = posOriToMatrix(
+                self._pos, self._ori, 
+                out=self._modelMatrix,
+                dtype=self.dtype)
+
+            # all other matrices need update when next accessed
+            self._cacheFlags['model'] = False
+            self._cacheFlags['imodel'] = True
+            self._cacheFlags['normal'] = True
+            self._cacheFlags['view'] = True
+            self._cacheFlags['iview'] = True
+
+        if not inverse:
+            toReturn = self._modelMatrix
+        else:
+            if self._cacheFlags['imodel']:
+                self._invModelMatrix = invertMatrix(
+                    self._modelMatrix, out=self._invModelMatrix, 
+                    dtype=self.dtype)
+                self._cacheFlags['imodel'] = False
+            
+            toReturn = self._invModelMatrix
+
+        if out is not None:
+            out[:, :] = toReturn[:, :]
+            return out
+
+        return toReturn
+
+    def getViewMatrix(self, inverse=False, out=None):
+        """Convert this pose into a view matrix.
+
+        Creates a view matrix which transforms points into eye space using the
+        current pose as the eye position in the scene. Furthermore, you can use
+        view matrices for rendering shadows if light positions are defined
+        as `RigidBodyPose` objects.
+
+        Parameters
+        ----------
+        inverse : bool
+            Return the inverse of the view matrix. Default is `False`.
+        out : ndarray or None
+            Optional 4x4 array to write values to. Values written are computed
+            using 32-bit float precision regardless of the data type of `out`.
+
+        Returns
+        -------
+        ndarray
+            4x4 transformation matrix.
+
+        """
+        if self._cacheFlags['view']:  # needs update?
+            # compute the view matrix
+            rotMatrix = quatToMatrix(self._ori, dtype=self.dtype)
+            transformedAxes = applyMatrix(
+                rotMatrix, self._viewAxes, 
+                dtype=self.dtype)
+
+            fwdVec = transformedAxes[0, :] + self._pos
+            upVec = transformedAxes[1, :]
+
+            self._viewMatrix = lookAt(
+                self._pos, fwdVec, upVec, 
+                out=self._viewMatrix,
+                dtype=self.dtype)
+
+            self._cacheFlags['view'] = False
+            self._cacheFlags['iview'] = True  # inverse needs update
+
+        if not inverse:
+            toReturn = self._viewMatrix
+        else:
+            if self._cacheFlags['iview']:
+                self._invViewMatrix = invertMatrix(
+                    self._viewMatrix, 
+                    out=self._invViewMatrix, 
+                    dtype=self.dtype)
+                self._cacheFlags['iview'] = False
+            
+            toReturn = self._invViewMatrix
+
+        if out is not None:
+            out[:, :] = toReturn[:, :]
+            return out
+
+        return toReturn
+
+    def transform(self, v, out=None):
+        """Transform a vector using this pose.
+
+        Parameters
+        ----------
+        v : array_like
+            Vector to transform [x, y, z].
+        out : ndarray or None, optional
+            Optional array to write values to. Must have the same shape as
+            `v`.
+
+        Returns
+        -------
+        ndarray
+            Transformed points.
+
+        """
+        return transform(
+            self._pos, self._ori, points=v, out=out, dtype=self.dtype)
+
+    def transformNormal(self, n):
+        """Rotate a normal vector with respect to this pose.
+
+        Rotates a normal vector `n` using the orientation quaternion at `ori`.
+
+        Parameters
+        ----------
+        n : array_like
+            Normal to rotate (1-D with length 3).
+
+        Returns
+        -------
+        ndarray
+            Rotated normal `n`.
+
+        """
+        pout = np.zeros((3,), dtype=self.dtype)
+        pout[:] = n
+        t = np.cross(self._ori[:3], n[:3]) * 2.0
+        u = np.cross(self._ori[:3], t)
+        t *= self._ori[3]
+        pout[:3] += t
+        pout[:3] += u
+
+        return pout
+
+    def __invert__(self):
+        """Operator `~` to invert the pose. Returns a `RigidBodyPose` object.
+        """
+        return RigidBodyPose(
+            -self._pos, invertQuat(self._ori, dtype=self.dtype))
+
+    def invert(self):
+        """Invert this pose.
+        """
+        self._ori = invertQuat(self._ori, dtype=self.dtype)
+        self._pos *= -1.0
+
+    def inverted(self):
+        """Get a pose which is the inverse of this one.
+
+        Returns
+        -------
+        RigidBodyPose
+            This pose inverted.
+
+        """
+        return RigidBodyPose(
+            -self._pos, invertQuat(self._ori, dtype=self.dtype))
+
+    def distanceTo(self, v):
+        """Get the distance to a pose or point in scene units.
+
+        Parameters
+        ----------
+        v : RigidBodyPose or array_like
+            Pose or point [x, y, z] to compute distance to.
+
+        Returns
+        -------
+        float
+            Distance to `v` from this pose's origin.
+
+        """
+        if hasattr(v, 'pos'):  # v is pose-like object
+            targetPos = v.pos
+        else:
+            targetPos = np.asarray(v[:3])
+
+        return np.sqrt(np.sum(np.square(targetPos - self.pos)))
+
+    def interp(self, end, s):
+        """Interpolate between poses.
+
+        Linear interpolation is used on position (Lerp) while the orientation
+        has spherical linear interpolation (Slerp) applied taking the shortest
+        arc on the hypersphere.
+
+        Parameters
+        ----------
+        end : RigidBodyPose
+            End pose.
+        s : float
+            Interpolation factor between interval 0.0 and 1.0.
+
+        Returns
+        -------
+        RigidBodyPose
+            Rigid body pose whose position and orientation is at `s` between
+            this pose and `end`.
+
+        """
+        if not (hasattr(end, 'pos') and hasattr(end, 'ori')):
+            raise TypeError("Object for `end` does not have attributes "
+                            "`pos` and `ori`.")
+
+        interpPos = lerp(self._pos, end.pos, s, dtype=self.dtype)
+        interpOri = slerp(self._ori, end.ori, s, dtype=self.dtype)
+
+        return RigidBodyPose(interpPos, interpOri)
+
+    def alignTo(self, alignTo):
+        """Align this pose to another point or pose.
+
+        This sets the orientation of this pose to one which orients the forward
+        axis towards `alignTo`.
+
+        Parameters
+        ----------
+        alignTo : array_like or RigidBodyPose
+            Position vector [x, y, z] or pose to align to.
+
+        """
+        if hasattr(alignTo, 'pos'):  # v is pose-like object
+            targetPos = alignTo.pos
+        else:
+            targetPos = np.asarray(alignTo[:3]) # handle array_like
+
+        fwd = np.asarray([0, 0, -1], dtype=self.dtype)
+        toTarget = targetPos - self._pos
+        invOri = invertQuat(self._ori, dtype=self.dtype)
+        invPos = applyQuat(invOri, toTarget, dtype=self.dtype)
+        invPos = normalize(invPos, dtype=self.dtype)
+
+        self.ori = multQuat(
+            self._ori, alignTo(fwd, invPos, dtype=self.dtype))
 
-VEC_AXES = {'+x': (1, 0, 0), '-x': (-1, 0, 0),
-            '+y': (0, 1, 0), '-y': (0, -1, 0),
-            '+z': (0, 0, 1), '-z': (0, 0, -1)}
+
+
+class BoundingBox:
+    """Class for representing object bounding boxes.
+
+    A bounding box is a construct which represents a 3D rectangular volume about
+    some pose, defined by its minimum and maximum extents in the reference frame
+    of the pose. The axes of the bounding box are aligned to the axes of the
+    world or the associated pose.
+
+    Bounding boxes are primarily used for visibility testing; to determine if
+    the extents of an object associated with a pose (eg. the vertices of a
+    model) falls completely outside of the viewing frustum. If so, the model can
+    be culled during rendering to avoid wasting CPU/GPU resources on objects not
+    visible to the viewer.
+
+    """
+    def __init__(self, extents=None, dtype=None):
+        self._dtype = np.dtype(dtype).type if dtype is not None else DEFAULT_DTYPE
+
+        self._extents = np.zeros((2, 3), self.dtype)
+        self._posCorners = np.zeros((8, 4), self.dtype)
+
+        if extents is not None:
+            self._extents[0, :] = extents[0]
+            self._extents[1, :] = extents[1]
+        else:
+            self.clear()
+
+        self._computeCorners()
+
+    def _computeCorners(self):
+        """Compute the corners of the bounding box.
+
+        These values are cached to speed up computations if extents hasn't been
+        updated.
+
+        """
+        for i in range(8):
+            self._posCorners[i, 0] = \
+                self._extents[1, 0] if (i & 1) else self._extents[0, 0]
+            self._posCorners[i, 1] = \
+                self._extents[1, 1] if (i & 2) else self._extents[0, 1]
+            self._posCorners[i, 2] = \
+                self._extents[1, 2] if (i & 4) else self._extents[0, 2]
+            self._posCorners[i, 3] = 1.0
+
+    @property
+    def dtype(self):
+        """Data type used for computations and arrays (`numpy.dtype`).
+        """
+        # we use 32-bit float precision for all computations, this will be 
+        # settable in the future
+        return self._dtype
+
+    @property
+    def isValid(self):
+        """`True` if the bounding box is valid."""
+        return np.all(self._extents[0, :] <= self._extents[1, :])
+
+    @property
+    def extents(self):
+        return self._extents
+
+    @extents.setter
+    def extents(self, value):
+        self._extents[0, :] = value[0]
+        self._extents[1, :] = value[1]
+        self._computeCorners()
+
+    def fit(self, verts):
+        """Fit the bounding box to vertices."""
+        np.amin(verts, axis=0, out=self._extents[0])
+        np.amax(verts, axis=0, out=self._extents[1])
+        self._computeCorners()
+
+    def clear(self):
+        """Clear a bounding box, invalidating it."""
+        self._extents[0, :] = np.finfo(self.dtype).max
+        self._extents[1, :] = np.finfo(self.dtype).min
+        self._computeCorners()
 
 
 # ------------------------------------------------------------------------------
@@ -106,9 +855,10 @@ def length(v, squared=False, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
+        toReturn = np.array(v, dtype=dtype)
     else:
-        dtype = np.dtype(out.dtype).type
+        toReturn = out
 
     v = np.asarray(v, dtype=dtype)
 
@@ -178,14 +928,14 @@ def normalize(v, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
         toReturn = np.array(v, dtype=dtype)
     else:
         toReturn = out
 
     v2d = np.atleast_2d(toReturn)  # 2d view of array
     norm = np.linalg.norm(v2d, axis=1)
-    norm[norm == 0.0] = np.NaN  # make sure if length==0 division succeeds
+    norm[norm == 0.0] = np.nan  # make sure if length==0 division succeeds
     v2d /= norm[:, np.newaxis]
     np.nan_to_num(v2d, copy=False)  # fix NaNs
 
@@ -224,7 +974,7 @@ def orthogonalize(v, n, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -273,7 +1023,7 @@ def reflect(v, n, out=None, dtype=None):
     """
     # based off https://github.com/glfw/glfw/blob/master/deps/linmath.h
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -326,7 +1076,7 @@ def dot(v0, v1, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -413,7 +1163,7 @@ def cross(v0, v1, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -492,7 +1242,7 @@ def project(v0, v1, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -550,7 +1300,7 @@ def lerp(v0, v1, t, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -599,7 +1349,7 @@ def distance(v0, v1, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -659,7 +1409,7 @@ def perp(v, n, norm=True, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -709,7 +1459,7 @@ def bisector(v0, v1, norm=False, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -767,7 +1517,7 @@ def angleTo(v, point, degrees=True, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -795,13 +1545,18 @@ def angleTo(v, point, degrees=True, out=None, dtype=None):
 
 
 def sortClockwise(verts):
-    """
-    Sort vertices clockwise from 12 O'Clock (aka vertex (0, 1)).
+    """Sort vertices clockwise from 12 O'Clock (aka vertex (0, 1)).
 
     Parameters
-    ==========
+    ----------
     verts : array
-        Array of vertices to sort
+        Array of vertices to sort.
+
+    Returns
+    -------
+    array
+        Vertices sorted clockwise from 12 O'Clock.
+
     """
     # Blank array of angles
     angles = []
@@ -856,12 +1611,12 @@ def surfaceNormal(tri, norm=True, out=None, dtype=None):
 
         vertices = [[[-1., 0., 0.], [0., 1., 0.], [1, 0, 0]],  # 2x3x3
                     [[1., 0., 0.], [0., 1., 0.], [-1, 0, 0]]]
-        normals = np.zeros((2, 3))  # normals from two triangles triangles
+        normals = np.zeros((2, 3))  # normals for two triangles
         surfaceNormal(vertices, out=normals)
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -945,7 +1700,7 @@ def surfaceBitangent(tri, uv, norm=True, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -1054,7 +1809,7 @@ def surfaceTangent(tri, uv, norm=True, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -1135,7 +1890,7 @@ def vertexNormal(faceNorms, norm=True, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -1188,7 +1943,7 @@ def fixTangentHandedness(tangents, normals, bitangents, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -1236,7 +1991,7 @@ def fitBBox(points, dtype=None):
     computeBBoxCorners : Convert bounding box extents to corners.
 
     """
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
 
     points = np.asarray(points, dtype=dtype)
     extents = np.zeros((2, 3), dtype=dtype)
@@ -1344,7 +2099,7 @@ def intersectRayPlane(rayOrig, rayDir, planeOrig, planeNormal, dtype=None):
         pnt, dist = intersectRayPlane(rayOrigin, rayDir, planeOrigin, planeNormal)
 
     """
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
 
     # based off the method from GLM
     rayOrig = np.asarray(rayOrig, dtype=dtype)
@@ -1395,7 +2150,7 @@ def intersectRaySphere(rayOrig, rayDir, sphereOrig=(0., 0., 0.), sphereRadius=1.
 
     """
     # based off example from https://antongerdelan.net/opengl/raycasting.html
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
 
     rayOrig = np.asarray(rayOrig, dtype=dtype)
     rayDir = np.asarray(rayDir, dtype=dtype)
@@ -1469,7 +2224,7 @@ def intersectRayAABB(rayOrig, rayDir, boundsOffset, boundsExtents, dtype=None):
     # based of the example provided here:
     # https://www.scratchapixel.com/lessons/3d-basic-rendering/
     # minimal-ray-tracer-rendering-simple-shapes/ray-box-intersection
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
 
     rayOrig = np.asarray(rayOrig, dtype=dtype)
     rayDir = np.asarray(rayDir, dtype=dtype)
@@ -1562,7 +2317,7 @@ def intersectRayOBB(rayOrig, rayDir, modelMatrix, boundsExtents, dtype=None):
     # based off algorithm:
     # https://www.opengl-tutorial.org/miscellaneous/clicking-on-objects/
     # picking-with-custom-ray-obb-function/
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
 
     rayOrig = np.asarray(rayOrig, dtype=dtype)
     rayDir = np.asarray(rayDir, dtype=dtype)
@@ -1637,7 +2392,7 @@ def intersectRayTriangle(rayOrig, rayDir, tri, dtype=None):
 
     """
     # based off `intersectRayTriangle` from GLM (https://glm.g-truc.net)
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
 
     rayOrig = np.asarray(rayOrig, dtype=dtype)
     rayDir = np.asarray(rayDir, dtype=dtype)
@@ -1739,7 +2494,7 @@ def ortho3Dto2D(p, orig, normal, up, right=None, dtype=None):
         planeX, planeY = ortho3Dto2D(pnt, planeOrigin, planeNormal, planeUpAxis)
 
     """
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
 
     p = np.asarray(p, dtype=dtype)
     orig = np.asarray(orig, dtype=dtype)
@@ -1823,7 +2578,7 @@ def articulate(boneVecs, boneOris, dtype=None):
         wristModel.thePose.posOri = (boxPos[2, :], boxOri[2, :])
 
     """
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
 
     boneVecs = np.asarray(boneVecs, dtype=dtype)
     boneOris = np.asarray(boneOris, dtype=dtype)
@@ -1914,7 +2669,7 @@ def slerp(q0, q1, t, shortest=True, out=None, dtype=None):
     #  https://en.wikipedia.org/wiki/Slerp
     #
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -1987,7 +2742,7 @@ def quatToAxisAngle(q, degrees=True, dtype=None):
         myStim.draw()
 
     """
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     q = normalize(q, dtype=dtype)  # returns ndarray
     v = np.sqrt(np.sum(np.square(q[:3])))
 
@@ -2039,7 +2794,7 @@ def quatFromAxisAngle(axis, angle, degrees=True, dtype=None):
         ori = quatFromAxisAngle(axis, angle, degrees=True)  # using degrees!
 
     """
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     toReturn = np.zeros((4,), dtype=dtype)
 
     if degrees:
@@ -2097,7 +2852,7 @@ def quatYawPitchRoll(q, degrees=True, out=None, dtype=None):
     # based off code found here:
     # https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles
     # Yields the same results as PsychXR's LibOVRPose.getYawPitchRoll method.
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     q = np.asarray(q, dtype=dtype)
 
     toReturn = np.zeros((3,), dtype=dtype) if out is None else out
@@ -2154,7 +2909,7 @@ def quatMagnitude(q, squared=False, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -2217,7 +2972,7 @@ def multQuat(q0, q1, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -2285,7 +3040,7 @@ def invertQuat(q, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -2362,7 +3117,7 @@ def applyQuat(q, points, out=None, dtype=None):
     """
     # based on 'quat_mul_vec3' implementation from linmath.h
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -2437,7 +3192,7 @@ def accumQuat(qlist, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -2501,7 +3256,7 @@ def alignTo(v, t, out=None, dtype=None):
     """
     # based off Quaternion::align from Quaternion.hpp from OpenMP
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -2610,7 +3365,7 @@ def matrixToQuat(m, out=None, dtype=None):
     # based off example `Maths - Conversion Matrix to Quaternion` from
     # https://www.euclideanspace.com/
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -2658,6 +3413,42 @@ def matrixToQuat(m, out=None, dtype=None):
 # Matrix Operations
 #
 
+def identityMatrix(size=4, out=None, dtype=None):
+    """Create an sqaure identity matrix.
+
+    Parameters
+    ----------
+    size : int, optional
+        Size of the matrix. Default is `4` for a 4x4 identity matrix.
+    out : ndarray, optional
+        Optional output array. Must be same `shape` and `dtype` as the expected
+        output if `out` was not specified.
+    dtype : dtype or str, optional
+        Data type for computations can either be 'float32' or 'float64'. If
+        `out` is specified, the data type of `out` is used and this argument is
+        ignored. If `out` is not provided, 'float64' is used by default.
+
+    Returns
+    -------
+    ndarray
+        Identity matrix.
+
+    """
+    # this might seem overkill for creating an identity matrix, but it is
+    # necessary to ensure the correct data type is used
+    if out is None:
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
+        ident = np.zeros((size, size), dtype=dtype)
+    else:
+        dtype = np.dtype(out.dtype).type
+        ident = out
+        ident.fill(0.0)
+
+    np.fill_diagonal(ident, 1.0)
+
+    return ident
+    
+
 def quatToMatrix(q, out=None, dtype=None):
     """Create a 4x4 rotation matrix from a quaternion.
 
@@ -2704,7 +3495,7 @@ def quatToMatrix(q, out=None, dtype=None):
     # based off implementations from
     # https://github.com/glfw/glfw/blob/master/deps/linmath.h
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
         R = np.zeros((4, 4,), dtype=dtype)
     else:
         dtype = np.dtype(out.dtype).type
@@ -2761,7 +3552,7 @@ def scaleMatrix(s, out=None, dtype=None):
     """
     # from glScale
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
         S = np.zeros((4, 4,), dtype=dtype)
     else:
         dtype = np.dtype(out.dtype).type
@@ -2814,7 +3605,7 @@ def rotationMatrix(angle, axis=(0., 0., -1.), out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
         R = np.zeros((4, 4,), dtype=dtype)
     else:
         dtype = np.dtype(out.dtype).type
@@ -2884,7 +3675,7 @@ def translationMatrix(t, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
         T = np.identity(4, dtype=dtype)
     else:
         dtype = np.dtype(out.dtype).type
@@ -2919,7 +3710,7 @@ def invertMatrix(m, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = out.dtype
 
@@ -3026,7 +3817,7 @@ def multMatrix(matrices, reverse=False, out=None, dtype=None):
 
     """
     # convert matrix types
-    dtype = np.float64 if dtype is None else np.dtype(dtype).type
+    dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     matrices = np.asarray(matrices, dtype=dtype)  # convert to array
 
     matrices = np.atleast_3d(matrices)
@@ -3199,7 +3990,7 @@ def matrixFromEulerAngles(rx, ry, rz, degrees=True, out=None, dtype=None):
     """
     # from https://www.j3d.org/matrix_faq/matrfaq_latest.html
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
         toReturn = np.zeros((4, 4,), dtype=dtype)
     else:
         dtype = np.dtype(dtype).type
@@ -3301,7 +4092,9 @@ def applyMatrix(m, points, out=None, dtype=None):
         Matrix with dimensions 2x2, 3x3, 3x4 or 4x4.
     points : array_like
         2D array of points/coordinates to transform. Each row should have length
-        appropriate for the matrix being used.
+        appropriate for the matrix being used. If not, a square submatrix will 
+        be taken from the input matrix with dimensions equal to the number of 
+        columns in `points`.
     out : ndarray, optional
         Optional output array. Must be same `shape` and `dtype` as the expected
         output if `out` was not specified.
@@ -3358,7 +4151,7 @@ def applyMatrix(m, points, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(out.dtype).type
 
@@ -3374,7 +4167,14 @@ def applyMatrix(m, points, out=None, dtype=None):
 
     pout, p = np.atleast_2d(toReturn, points)
 
-    if m.shape[0] == m.shape[1] == 4:  # 4x4 matrix
+    nCols = p.shape[1]
+    if m.shape[0] > nCols:
+        if m.shape[1] < nCols:
+            raise ValueError(
+                'Input matrix dimensions are not compatible with input array.')
+        m = m[:nCols, :nCols]  # take sub matrix
+
+    if m.shape == (4, 4):  # 4x4 matrix
         if pout.shape[1] == 3:  # Nx3
             pout[:, :] = p.dot(m[:3, :3].T)
             pout += m[:3, 3]
@@ -3392,7 +4192,7 @@ def applyMatrix(m, points, out=None, dtype=None):
             raise ValueError(
                 'Input array dimensions invalid. Should be Nx3 or Nx4 when '
                 'input matrix is 4x4.')
-    elif m.shape[0] == 3 and m.shape[1] == 4:  # 3x4 matrix
+    elif m.shape == (3, 4):  # 3x4 matrix
         if pout.shape[1] == 3:  # Nx3
             pout[:, :] = p.dot(m[:3, :3].T)
             pout += m[:3, 3]
@@ -3400,14 +4200,14 @@ def applyMatrix(m, points, out=None, dtype=None):
             raise ValueError(
                 'Input array dimensions invalid. Should be Nx3 when input '
                 'matrix is 3x4.')
-    elif m.shape[0] == m.shape[1] == 3:  # 3x3 matrix, e.g colors
+    elif m.shape == (3, 3):  # 3x3 matrix, e.g colors
         if pout.shape[1] == 3:  # Nx3
             pout[:, :] = p.dot(m.T)
         else:
             raise ValueError(
                 'Input array dimensions invalid. Should be Nx3 when '
                 'input matrix is 3x3.')
-    elif m.shape[0] == m.shape[1] == pout.shape[1] == 2:  # 2x2 matrix
+    elif m.shape == (2, 2):  # 2x2 matrix
         if pout.shape[1] == 2:  # Nx2
             pout[:, :] = p.dot(m.T)
         else:
@@ -3449,7 +4249,7 @@ def posOriToMatrix(pos, ori, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
         toReturn = np.zeros((4, 4,), dtype=dtype)
     else:
         dtype = np.dtype(dtype).type
@@ -3520,7 +4320,7 @@ def transform(pos, ori, points, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(dtype).type
 
@@ -3600,7 +4400,7 @@ def scale(sf, points, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(dtype).type
 
@@ -3645,7 +4445,7 @@ def normalMatrix(modelMatrix, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(dtype).type
 
@@ -3693,7 +4493,7 @@ def forwardProject(objPos, modelView, proj, viewport=None, out=None, dtype=None)
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(dtype).type
 
@@ -3769,7 +4569,7 @@ def reverseProject(winPos, modelView, proj, viewport=None, out=None, dtype=None)
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(dtype).type
 
@@ -3793,6 +4593,76 @@ def reverseProject(winPos, modelView, proj, viewport=None, out=None, dtype=None)
     return toReturn  # ref to objCoord
 
 
+def lookAt(eyePos, centerPos, upVec=(0.0, 1.0, 0.0), out=None, dtype=None):
+    """Create a transformation matrix to orient a view towards some point. 
+    
+    Based on the same algorithm as 'gluLookAt'. This does not generate a 
+    projection matrix, but rather the matrix to transform the observer's view in 
+    the scene.
+
+    For more information see:
+    https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml
+
+    Parameters
+    ----------
+    eyePos : list of float or ndarray
+        Eye position in the scene.
+    centerPos : list of float or ndarray
+        Position of the object center in the scene.
+    upVec : list of float or ndarray, optional
+        Vector defining the up vector. Default is +Y is up.
+    out : ndarray, optional
+        Optional output array. Must be same `shape` and `dtype` as the expected
+        output if `out` was not specified.
+    dtype : dtype or str, optional
+        Data type for arrays, can either be 'float32' or 'float64'. If `None` is
+        specified, the data type is inferred by `out`. If `out` is not provided,
+        the default is 'float64'.
+
+    Returns
+    -------
+    ndarray
+        4x4 view matrix
+
+    Notes
+    -----
+    * This function was moved from `viewtools` in version 2025.1.0.
+    * The returned matrix is row-major. Values are floats with 32-bits of
+      precision stored as a contiguous (C-order) array.
+
+    """
+    if out is None:
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
+    else:
+        dtype = np.dtype(out.dtype).type
+
+    toReturn = np.zeros((4, 4,), dtype=dtype) if out is None else out
+    if out is not None:
+        toReturn.fill(0.0)
+
+    eyePos = np.asarray(eyePos, dtype=dtype)
+    centerPos = np.asarray(centerPos, dtype=dtype)
+    upVec = np.asarray(upVec, dtype=dtype)
+
+    f = centerPos - eyePos
+    f /= np.linalg.norm(f)
+    upVec /= np.linalg.norm(upVec)
+
+    s = np.cross(f, upVec)
+    u = np.cross(s / np.linalg.norm(s), f)
+
+    rotMat = np.zeros((4, 4), dtype=dtype)
+    rotMat[0, :3] = s
+    rotMat[1, :3] = u
+    rotMat[2, :3] = -f
+    rotMat[3, 3] = 1.0
+ 
+    transMat = np.identity(4, dtype=dtype)
+    transMat[:3, 3] = -eyePos
+
+    return np.matmul(rotMat, transMat, out=toReturn)
+
+
 # ------------------------------------------------------------------------------
 # Misc. Math Functions
 #
@@ -3892,7 +4762,7 @@ def lensCorrection(xys, coefK=(1.0,), distCenter=(0., 0.), out=None,
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(dtype).type
 
@@ -3961,7 +4831,7 @@ def lensCorrectionSpherical(xys, coefK=1.0, aspect=1.0, out=None, dtype=None):
 
     """
     if out is None:
-        dtype = np.float64 if dtype is None else np.dtype(dtype).type
+        dtype = DEFAULT_DTYPE if dtype is None else np.dtype(dtype).type
     else:
         dtype = np.dtype(dtype).type