vispy 0.11.0__cp310-cp310-macosx_10_9_x86_64.whl → 0.14.0__cp310-cp310-macosx_10_9_x86_64.whl

vispy/app/backends/_glfw.py

@@ -27,7 +27,7 @@ glfw = None
 try:
     import glfw
 except ImportError:
-    why_not = "Could not import glwf, you may need to `pip install glfw` first."
+    why_not = "Could not import glfw, you may need to `pip install glfw` first."
     available, testable, why_not, which = False, False, why_not, None
 except Exception as err:
     why_not = "Error importing glfw: " + str(err)
@@ -250,7 +250,7 @@ class CanvasBackend(BaseCanvasBackend):
                     raise ValueError('fullscreen must be <= %s'
                                      % len(monitor))
                 monitor = monitor[p.fullscreen]
-            use_size = glfw.get_video_mode(monitor)[:2]
+            use_size = glfw.get_video_mode(monitor)[0][:2]
             if use_size != tuple(p.size):
                 logger.debug('Requested size %s, will be ignored to '
                              'use fullscreen mode %s' % (p.size, use_size))

vispy/app/backends/_pyglet.py

@@ -6,7 +6,7 @@
 
 from __future__ import division
 
-from distutils.version import LooseVersion
+from packaging.version import Version
 from time import sleep
 
 from ..base import (BaseApplicationBackend, BaseCanvasBackend,
@@ -23,7 +23,7 @@ USE_EGL = config['gl_backend'].lower().startswith('es')
 try:
     import pyglet
     version = pyglet.version
-    if LooseVersion(version) < LooseVersion('1.2'):
+    if Version(version) < Version('1.2'):
         help_ = ('You can install the latest pyglet using:\n    '
                  'pip install http://pyglet.googlecode.com/archive/tip.zip')
         raise ImportError('Pyglet version too old (%s), need >= 1.2\n%s'

vispy/app/backends/_qt.py

@@ -22,11 +22,12 @@ known to cause unpredictable behavior and segfaults.
 from __future__ import division
 
 from time import sleep, time
+import math
 import os
 import sys
 import atexit
 import ctypes
-from distutils.version import LooseVersion
+from packaging.version import Version
 
 from ...util import logger
 from ..base import (BaseApplicationBackend, BaseCanvasBackend,
@@ -90,7 +91,7 @@ elif qt_lib == 'pyqt5':
     _check_imports('PyQt5')
     if not USE_EGL:
         from PyQt5.QtCore import QT_VERSION_STR
-        if LooseVersion(QT_VERSION_STR) >= '5.4.0':
+        if Version(QT_VERSION_STR) >= Version('5.4.0'):
             from PyQt5.QtWidgets import QOpenGLWidget as QGLWidget
             from PyQt5.QtGui import QSurfaceFormat as QGLFormat
             QT5_NEW_API = True
@@ -102,7 +103,7 @@ elif qt_lib == 'pyqt6':
     _check_imports('PyQt6')
     if not USE_EGL:
         from PyQt6.QtCore import QT_VERSION_STR
-        if LooseVersion(QT_VERSION_STR) >= '6.0.0':
+        if Version(QT_VERSION_STR) >= Version('6.0.0'):
             from PyQt6.QtOpenGLWidgets import QOpenGLWidget as QGLWidget
             from PyQt6.QtGui import QSurfaceFormat as QGLFormat
             PYQT6_API = True
@@ -114,7 +115,7 @@ elif qt_lib == 'pyside6':
     _check_imports('PySide6')
     if not USE_EGL:
         from PySide6.QtCore import __version__ as QT_VERSION_STR
-        if LooseVersion(QT_VERSION_STR) >= '6.0.0':
+        if Version(QT_VERSION_STR) >= Version('6.0.0'):
             from PySide6.QtOpenGLWidgets import QOpenGLWidget as QGLWidget
             from PySide6.QtGui import QSurfaceFormat as QGLFormat
             PYSIDE6_API = True
@@ -126,7 +127,7 @@ elif qt_lib == 'pyside2':
     _check_imports('PySide2')
     if not USE_EGL:
         from PySide2.QtCore import __version__ as QT_VERSION_STR
-        if LooseVersion(QT_VERSION_STR) >= '5.4.0':
+        if Version(QT_VERSION_STR) >= Version('5.4.0'):
             from PySide2.QtWidgets import QOpenGLWidget as QGLWidget
             from PySide2.QtGui import QSurfaceFormat as QGLFormat
             QT5_NEW_API = True
@@ -191,7 +192,7 @@ KEYMAP = {
     qt_keys.Key_Return: keys.ENTER,
     qt_keys.Key_Tab: keys.TAB,
 }
-if PYQT6_API:
+if PYQT6_API or PYSIDE6_API:
     BUTTONMAP = {
         QtCore.Qt.MouseButton.NoButton: 0,
         QtCore.Qt.MouseButton.LeftButton: 1,
@@ -278,11 +279,11 @@ def _set_config(c):
     glformat.setGreenBufferSize(c['green_size'])
     glformat.setBlueBufferSize(c['blue_size'])
     glformat.setAlphaBufferSize(c['alpha_size'])
-    if QT5_NEW_API or PYSIDE6_API:
+    if QT5_NEW_API:
         # Qt5 >= 5.4.0 - below options automatically enabled if nonzero.
         glformat.setSwapBehavior(glformat.DoubleBuffer if c['double_buffer']
                                  else glformat.SingleBuffer)
-    elif PYQT6_API:
+    elif PYQT6_API or PYSIDE6_API:
         glformat.setSwapBehavior(glformat.SwapBehavior.DoubleBuffer if c['double_buffer']
                                  else glformat.SwapBehavior.SingleBuffer)
     else:
@@ -410,17 +411,10 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
             # either not PyQt5 backend or no parent window available
             pass
 
-        # Activate touch and gesture.
-        # NOTE: we only activate touch on OS X because there seems to be
-        # problems on Ubuntu computers with touchscreen.
-        # See https://github.com/vispy/vispy/pull/1143
-        if sys.platform == 'darwin':
-            if PYQT6_API:
-                self.setAttribute(QtCore.Qt.WidgetAttribute.WA_AcceptTouchEvents)
-                self.grabGesture(QtCore.Qt.GestureType.PinchGesture)
-            else:
-                self.setAttribute(QtCore.Qt.WA_AcceptTouchEvents)
-                self.grabGesture(QtCore.Qt.PinchGesture)
+        # QNativeGestureEvent does not keep track of last or total
+        # values like QGestureEvent does
+        self._native_gesture_scale_values = []
+        self._native_gesture_rotation_values = []
 
     def screen_changed(self, new_screen):
         """Window moved from one display to another, resize canvas.
@@ -563,50 +557,81 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
     def keyReleaseEvent(self, ev):
         self._keyEvent(self._vispy_canvas.events.key_release, ev)
 
+    def _handle_native_gesture_event(self, ev):
+        if self._vispy_canvas is None:
+            return
+        t = ev.gestureType()
+        # this is a workaround for what looks like a Qt bug where
+        # QNativeGestureEvent gives the wrong local position.
+        # See: https://bugreports.qt.io/browse/QTBUG-59595
+        try:
+            pos = self.mapFromGlobal(ev.globalPosition().toPoint())
+        except AttributeError:
+            # globalPos is deprecated in Qt6
+            pos = self.mapFromGlobal(ev.globalPos())
+        pos = pos.x(), pos.y()
+
+        if t == QtCore.Qt.NativeGestureType.BeginNativeGesture:
+            self._vispy_canvas.events.touch(
+                type='gesture_begin',
+                pos=_get_event_xy(ev),
+            )
+        elif t == QtCore.Qt.NativeGestureType.EndNativeGesture:
+            self._native_touch_total_rotation = []
+            self._native_touch_total_scale = []
+            self._vispy_canvas.events.touch(
+                type='gesture_end',
+                pos=_get_event_xy(ev),
+            )
+        elif t == QtCore.Qt.NativeGestureType.RotateNativeGesture:
+            angle = ev.value()
+            last_angle = (
+                self._native_gesture_rotation_values[-1]
+                if self._native_gesture_rotation_values
+                else None
+            )
+            self._native_gesture_rotation_values.append(angle)
+            total_rotation_angle = math.fsum(self._native_gesture_rotation_values)
+            self._vispy_canvas.events.touch(
+                type="gesture_rotate",
+                pos=pos,
+                rotation=angle,
+                last_rotation=last_angle,
+                total_rotation_angle=total_rotation_angle,
+            )
+        elif t == QtCore.Qt.NativeGestureType.ZoomNativeGesture:
+            scale = ev.value()
+            last_scale = (
+                self._native_gesture_scale_values[-1]
+                if self._native_gesture_scale_values
+                else None
+            )
+            self._native_gesture_scale_values.append(scale)
+            total_scale_factor = math.fsum(self._native_gesture_scale_values)
+            self._vispy_canvas.events.touch(
+                type="gesture_zoom",
+                pos=pos,
+                last_scale=last_scale,
+                scale=scale,
+                total_scale_factor=total_scale_factor,
+            )
+        # QtCore.Qt.NativeGestureType.PanNativeGesture
+        # Qt6 docs seem to imply this is only supported on Wayland but I have
+        # not been able to test it.
+        # Two finger pan events are anyway converted to scroll/wheel events.
+        # On macOS, more fingers are usually swallowed by the OS (by spaces,
+        # mission control, etc.).
+
     def event(self, ev):
         out = super(QtBaseCanvasBackend, self).event(ev)
-        t = ev.type()
-
-        qt_event_types = QtCore.QEvent.Type if PYQT6_API else QtCore.QEvent
-        # Two-finger pinch.
-        if t == qt_event_types.TouchBegin:
-            self._vispy_canvas.events.touch(type='begin')
-        if t == qt_event_types.TouchEnd:
-            self._vispy_canvas.events.touch(type='end')
-        if t == qt_event_types.Gesture:
-            pinch_gesture = QtCore.Qt.GestureType.PinchGesture if PYQT6_API else QtCore.Qt.PinchGesture
-            gesture = ev.gesture(pinch_gesture)
-            if gesture:
-                (x, y) = _get_qpoint_pos(gesture.centerPoint())
-                scale = gesture.scaleFactor()
-                last_scale = gesture.lastScaleFactor()
-                rotation = gesture.rotationAngle()
-                self._vispy_canvas.events.touch(
-                    type="pinch",
-                    pos=(x, y),
-                    last_pos=None,
-                    scale=scale,
-                    last_scale=last_scale,
-                    rotation=rotation,
-                    total_rotation_angle=gesture.totalRotationAngle(),
-                    total_scale_factor=gesture.totalScaleFactor(),
-                )
-        # General touch event.
-        elif t == qt_event_types.TouchUpdate:
-            if qt_lib == 'pyqt6' or qt_lib == 'pyside6':
-                points = ev.points()
-                # These variables are lists of (x, y) coordinates.
-                pos = [_get_qpoint_pos(p.position()) for p in points]
-                lpos = [_get_qpoint_pos(p.lastPosition()) for p in points]
-            else:
-                points = ev.touchPoints()
-                # These variables are lists of (x, y) coordinates.
-                pos = [_get_qpoint_pos(p.pos()) for p in points]
-                lpos = [_get_qpoint_pos(p.lastPos()) for p in points]
-            self._vispy_canvas.events.touch(type='touch',
-                                            pos=pos,
-                                            last_pos=lpos,
-                                            )
+
+        # QNativeGestureEvent is Qt 5+
+        if (
+            (QT5_NEW_API or PYSIDE6_API or PYQT6_API)
+            and isinstance(ev, QtGui.QNativeGestureEvent)
+        ):
+            self._handle_native_gesture_event(ev)
+
         return out
 
     def _keyEvent(self, func, ev):

vispy/app/backends/_wx.py

@@ -466,7 +466,7 @@ class TimerBackend(BaseTimerBackend):
         parent.Bind(wx.EVT_TIMER, self._vispy_timeout, self._timer)
 
     def _vispy_start(self, interval):
-        self._timer.Start(interval * 1000., False)
+        self._timer.Start(int(interval * 1000.), False)
 
     def _vispy_stop(self):
         self._timer.Stop()

vispy/app/canvas.py

@@ -606,7 +606,7 @@ class MouseEvent(Event):
         will return the button that started the drag (same thing as
         ``event.press_event.button``).
     buttons : [int, ...]
-        The list of buttons depressed during this event.
+        The list of buttons pressed during this event.
     modifiers : tuple of Key instances
         Tuple that specifies which modifier keys were pressed down at the
         time of the event (shift, control, alt, meta).
@@ -632,7 +632,9 @@ class MouseEvent(Event):
         Event.__init__(self, type, **kwargs)
         self._pos = np.array([0, 0]) if (pos is None) else np.array(pos)
         self._button = int(button) if (button is not None) else None
-        self._buttons = [] if (buttons is None) else buttons
+        # Explicitly add button to buttons if newly pressed, check #2344 for more reference
+        newly_pressed_buttons = [button] if button is not None and type == 'mouse_press' else []
+        self._buttons = [] if (buttons is None) else buttons + newly_pressed_buttons
         self._modifiers = tuple(modifiers or ())
         self._delta = np.zeros(2) if (delta is None) else np.array(delta)
         self._last_event = last_event

vispy/app/tests/test_canvas.py

@@ -2,7 +2,7 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
-from vispy.app import Canvas
+from vispy.app import Canvas, MouseEvent
 from vispy.visuals import ImageVisual
 from vispy.testing import requires_application
 from vispy.visuals.transforms import STTransform
@@ -106,3 +106,17 @@ def test_blend_presets(preset):
             
         rgba_result = c.render()
         assert not np.allclose(rgba_result[..., :3], 0)
+
+
+@requires_application()
+@pytest.mark.parametrize("mouse_event_type, button, buttons, expected_button, expected_buttons", [
+    ('mouse_press', 1, [], 1, [1]),
+    ('mouse_release', 1, [1], 1, [1]),
+    # left click pressed and held, followed by a right click
+    ('mouse_press', 2, [1], 2, [1, 2]),
+    ('mouse_release', 2, [1, 2], 2, [1, 2]),
+])
+def test_mouse_event(mouse_event_type, button, buttons, expected_button, expected_buttons):
+    mev = MouseEvent(type=mouse_event_type, button=button, buttons=buttons)
+    assert mev.buttons == expected_buttons
+    assert mev.button == expected_button

vispy/app/tests/test_context.py

@@ -17,6 +17,8 @@ def test_context_properties():
         return  # cannot set more than once on Pyglet
     if a.backend_name.lower() == 'osmesa':
         return  # cannot set config on OSMesa
+    if 'pyqt5' in a.backend_name.lower() or 'pyqt6' in a.backend_name.lower() or 'pyside2' in a.backend_name.lower() or 'pyside6' in a.backend_name.lower():
+        pytest.xfail("Context sharing is not supported in PyQt5, PyQt6, PySide2, or PySide6 at this time.")
 
     # stereo, double buffer won't work on every sys
     configs = [dict(samples=4), dict(stencil_size=8),
@@ -68,9 +70,9 @@ def test_context_sharing():
         # Check while c1 is active
         check()
 
-        # pyqt5 does not currently support context sharing
-        if 'pyqt5' in c1.app.backend_name.lower() or 'pyqt6' in c1.app.backend_name.lower():
-            pytest.xfail("Context sharing is not supported in PyQt5 at this time.")
+        # pyqt5 does not currently support context sharing, pyside6 seg faults on app tests
+        if 'pyqt5' in c1.app.backend_name.lower() or 'pyqt6' in c1.app.backend_name.lower() or 'pyside2' in c1.app.backend_name.lower() or 'pyside6' in c1.app.backend_name.lower():
+            pytest.xfail("Context sharing is not supported in PyQt5, PyQt6, PySide2, or PySide6 at this time.")
 
         # Tkinter does not currently support context sharing
         if 'tk' in c1.app.backend_name.lower():

vispy/color/color_array.py

@@ -21,7 +21,7 @@ def _string_to_rgb(color):
     if not color.startswith('#'):
         if color.lower() not in _color_dict:
             raise ValueError('Color "%s" unknown' % color)
-        color = _color_dict[color]
+        color = _color_dict[color.lower()]
         assert color[0] == '#'
     # hex color
     color = color[1:]
@@ -163,6 +163,13 @@ class ColorArray(object):
         """Helper to get the class name once it's been created"""
         return cls.__name__
 
+    def __array__(self, dtype=None):
+        """Get a standard numpy array representing RGBA."""
+        rgba = self.rgba
+        if dtype is not None:
+            rgba = rgba.astype(dtype)
+        return rgba
+
     def __len__(self):
         return self._rgba.shape[0]
 

vispy/color/colormap.py

@@ -435,7 +435,7 @@ class Colormap(BaseColormap):
         if self.texture_map_data is None:
             return None
         interp = 'linear' if self.interpolation == 'linear' else 'nearest'
-        texture_LUT = vispy.gloo.Texture2D(np.zeros(self.texture_map_data.shape),
+        texture_LUT = vispy.gloo.Texture2D(np.zeros(self.texture_map_data.shape, dtype=np.float32),
                                            interpolation=interp)
         texture_LUT.set_data(self.texture_map_data, offset=None, copy=True)
         return texture_LUT
@@ -1092,17 +1092,13 @@ _colormaps = dict(
 )
 
 
-def get_colormap(name, *args, **kwargs):
-    """Obtain a colormap.
+def get_colormap(name):
+    """Obtain a colormap by name.
 
     Parameters
     ----------
     name : str | Colormap
         Colormap name. Can also be a Colormap for pass-through.
-    *args:
-        Deprecated.
-    **kwargs
-        Deprecated.
 
     Examples
     --------
@@ -1111,18 +1107,10 @@ def get_colormap(name, *args, **kwargs):
 
     .. versionchanged: 0.7
 
-        Additional args/kwargs are no longer accepted. Colormap classes are
-        no longer created on the fly. To create a ``cubehelix``
-        (``CubeHelixColormap``), ``single_hue`` (``SingleHue``), ``hsl``
-        (``HSL``), ``husl`` (``HSLuv``), ``diverging`` (``Diverging``), or
-        ``RdYeBuCy`` (``RedYellowBlueCyan``) colormap you must import and
-        instantiate it directly from the ``vispy.color.colormap`` module.
+        Additional args/kwargs are no longer accepted. Colormap instances are
+        no longer created on the fly.
 
     """
-    if args or kwargs:
-        warnings.warn("Creating a Colormap instance with 'get_colormap' is "
-                      "no longer supported. No additional arguments or "
-                      "keyword arguments should be passed.", DeprecationWarning)
     if isinstance(name, BaseColormap):
         return name
 
@@ -1130,14 +1118,6 @@ def get_colormap(name, *args, **kwargs):
         raise TypeError('colormap must be a Colormap or string name')
     if name in _colormaps:  # vispy cmap
         cmap = _colormaps[name]
-        if name in ("cubehelix", "single_hue", "hsl", "husl", "diverging", "RdYeBuCy"):
-            warnings.warn(
-                f"Colormap '{name}' has been deprecated since vispy 0.7. "
-                f"Please import and create 'vispy.color.colormap.{cmap.__class__.__name__}' "
-                "directly instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
 
     elif has_matplotlib():  # matplotlib cmap
         try:

vispy/geometry/meshdata.py

@@ -19,6 +19,56 @@ def _fix_colors(colors):
     return colors
 
 
+def _compute_face_normals(vertices):
+    if vertices.shape[1:] != (3, 3):
+        raise ValueError("Expected (N, 3, 3) array of vertices repeated on"
+                         f" the triangle corners, got {vertices.shape}.")
+    edges1 = vertices[:, 1] - vertices[:, 0]
+    edges2 = vertices[:, 2] - vertices[:, 0]
+    return np.cross(edges1, edges2)
+
+
+def _repeat_face_normals_on_corners(normals):
+    if normals.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face normals, got"
+                         f" {normals.shape}.")
+    n_corners_in_face = 3
+    new_shape = (normals.shape[0], n_corners_in_face, normals.shape[1])
+    return np.repeat(normals, n_corners_in_face, axis=0).reshape(new_shape)
+
+
+def _compute_vertex_normals(face_normals, faces, vertices):
+    if face_normals.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face normals, got"
+                         f" {face_normals.shape}.")
+    if faces.shape[1:] != (3,):
+        raise ValueError("Expected (F, 3) array of face vertex indices, got"
+                         f" {faces.shape}.")
+    if vertices.shape[1:] != (3,):
+        raise ValueError("Expected (N, 3) array of vertices, got"
+                         f" {vertices.shape}.")
+
+    vertex_normals = np.zeros_like(vertices)
+    n_corners_in_triangle = 3
+    face_normals_repeated_on_corners = np.repeat(face_normals,
+                                                 n_corners_in_triangle,
+                                                 axis=0)
+    # NOTE: The next line is equivalent to
+    #
+    #   vertex_normals[self._faces.ravel()] += face_normals_repeated_on_corners
+    #
+    # except that it accumulates the values from the right hand side at
+    # repeated indices on the left hand side, instead of overwritting them,
+    # like in the above.
+    np.add.at(vertex_normals, faces.ravel(), face_normals_repeated_on_corners)
+
+    norms = np.sqrt((vertex_normals**2).sum(axis=1))
+    nonzero_norms = norms > 0
+    vertex_normals[nonzero_norms] /= norms[nonzero_norms][:, None]
+
+    return vertex_normals
+
+
 class MeshData(object):
     """
     Class for storing and operating on 3D mesh data.
@@ -141,7 +191,7 @@ class MeshData(object):
                 self._compute_edges(indexed='faces')
             return self._edges_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_faces(self, faces):
         """Set the faces
@@ -191,7 +241,7 @@ class MeshData(object):
                     self._vertices[self.get_faces()]
             return self._vertices_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_bounds(self):
         """Get the mesh bounds
@@ -234,7 +284,7 @@ class MeshData(object):
             if verts is not None:
                 self._vertices_indexed_by_faces = verts
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
         if reset_normals:
             self.reset_normals()
@@ -293,22 +343,19 @@ class MeshData(object):
         normals : ndarray
             The normals.
         """
+        if indexed not in (None, 'faces'):
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
+
         if self._face_normals is None:
-            v = self.get_vertices(indexed='faces')
-            self._face_normals = np.cross(v[:, 1] - v[:, 0],
-                                          v[:, 2] - v[:, 0])
+            vertices = self.get_vertices(indexed='faces')
+            self._face_normals = _compute_face_normals(vertices)
 
-        if indexed is None:
-            return self._face_normals
-        elif indexed == 'faces':
-            if self._face_normals_indexed_by_faces is None:
-                norms = np.empty((self._face_normals.shape[0], 3, 3),
-                                 dtype=np.float32)
-                norms[:] = self._face_normals[:, np.newaxis, :]
-                self._face_normals_indexed_by_faces = norms
-            return self._face_normals_indexed_by_faces
-        else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+        if indexed == 'faces' and self._face_normals_indexed_by_faces is None:
+            self._face_normals_indexed_by_faces = \
+                _repeat_face_normals_on_corners(self._face_normals)
+
+        return (self._face_normals if indexed is None
+                else self._face_normals_indexed_by_faces)
 
     def get_vertex_normals(self, indexed=None):
         """Get vertex normals
@@ -326,29 +373,20 @@ class MeshData(object):
         normals : ndarray
             The normals.
         """
+        if indexed not in (None, 'faces'):
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
+
         if self._vertex_normals is None:
-            faceNorms = self.get_face_normals()
-            vertFaces = self.get_vertex_faces()
-            self._vertex_normals = np.empty(self._vertices.shape,
-                                            dtype=np.float32)
-            for vindex in range(self._vertices.shape[0]):
-                faces = vertFaces[vindex]
-                if len(faces) == 0:
-                    self._vertex_normals[vindex] = (0, 0, 0)
-                    continue
-                norms = faceNorms[faces]  # get all face normals
-                norm = norms.sum(axis=0)  # sum normals
-                renorm = (norm**2).sum()**0.5
-                if renorm > 0:
-                    norm /= renorm
-                self._vertex_normals[vindex] = norm
+            face_normals = self.get_face_normals()
+            faces = self.get_faces()
+            vertices = self.get_vertices()
+            self._vertex_normals = _compute_vertex_normals(face_normals, faces,
+                                                           vertices)
 
         if indexed is None:
             return self._vertex_normals
         elif indexed == 'faces':
             return self._vertex_normals[self.get_faces()]
-        else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_vertex_colors(self, indexed=None):
         """Get vertex colors
@@ -373,7 +411,7 @@ class MeshData(object):
                     self._vertex_colors[self.get_faces()]
             return self._vertex_colors_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def get_vertex_values(self, indexed=None):
         """Get vertex colors
@@ -398,7 +436,7 @@ class MeshData(object):
                     self._vertex_values[self.get_faces()]
             return self._vertex_values_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_vertex_colors(self, colors, indexed=None):
         """Set the vertex color array
@@ -488,7 +526,7 @@ class MeshData(object):
                     self._face_colors.reshape(Nf, 1, 4)
             return self._face_colors_indexed_by_faces
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def set_face_colors(self, colors, indexed=None):
         """Set the face color array
@@ -611,7 +649,7 @@ class MeshData(object):
                 raise Exception("MeshData cannot generate edges--no faces in "
                                 "this data.")
         else:
-            raise Exception("Invalid indexing mode. Accepts: None, 'faces'")
+            raise ValueError("Invalid indexing mode. Accepts: None, 'faces'")
 
     def save(self):
         """Serialize this mesh to a string appropriate for disk storage