vispy 0.14.3__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.15.2__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

vispy/app/backends/_qt.py

@@ -493,41 +493,57 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
     def mousePressEvent(self, ev):
         if self._vispy_canvas is None:
             return
-        self._vispy_mouse_press(
+        vispy_event = self._vispy_mouse_press(
             native=ev,
             pos=_get_event_xy(ev),
             button=BUTTONMAP.get(ev.button(), 0),
             modifiers=self._modifiers(ev),
         )
+        # If vispy did not handle the event, clear the accept parameter of the qt event
+        if not vispy_event.handled:
+            ev.ignore()
 
     def mouseReleaseEvent(self, ev):
         if self._vispy_canvas is None:
             return
-        self._vispy_mouse_release(
+        vispy_event = self._vispy_mouse_release(
             native=ev,
             pos=_get_event_xy(ev),
             button=BUTTONMAP[ev.button()],
             modifiers=self._modifiers(ev),
         )
+        # If vispy did not handle the event, clear the accept parameter of the qt event
+        if not vispy_event.handled:
+            ev.ignore()
 
     def mouseDoubleClickEvent(self, ev):
         if self._vispy_canvas is None:
             return
-        self._vispy_mouse_double_click(
+        vispy_event = self._vispy_mouse_double_click(
             native=ev,
             pos=_get_event_xy(ev),
             button=BUTTONMAP.get(ev.button(), 0),
             modifiers=self._modifiers(ev),
         )
+        # If vispy did not handle the event, clear the accept parameter of the qt event
+        if not vispy_event.handled:
+            ev.ignore()
 
     def mouseMoveEvent(self, ev):
         if self._vispy_canvas is None:
             return
-        self._vispy_mouse_move(
+        # NB ignores events, returns None for events in quick succession
+        vispy_event = self._vispy_mouse_move(
             native=ev,
             pos=_get_event_xy(ev),
             modifiers=self._modifiers(ev),
         )
+        # If vispy did not handle the event, clear the accept parameter of the qt event
+        # Note that the handler can return None, this is equivalent to not handling the event
+        if vispy_event is None or not vispy_event.handled:
+            # Theoretically, a parent widget might want to listen to all of
+            # the mouse move events, including those that VisPy ignores
+            ev.ignore()
 
     def wheelEvent(self, ev):
         if self._vispy_canvas is None:
@@ -544,12 +560,15 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
             delta = ev.angleDelta()
             deltax, deltay = delta.x() / 120.0, delta.y() / 120.0
         # Emit event
-        self._vispy_canvas.events.mouse_wheel(
+        vispy_event = self._vispy_canvas.events.mouse_wheel(
             native=ev,
             delta=(deltax, deltay),
             pos=_get_event_xy(ev),
             modifiers=self._modifiers(ev),
         )
+        # If vispy did not handle the event, clear the accept parameter of the qt event
+        if not vispy_event.handled:
+            ev.ignore()
 
     def keyPressEvent(self, ev):
         self._keyEvent(self._vispy_canvas.events.key_press, ev)
@@ -571,17 +590,20 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
             pos = self.mapFromGlobal(ev.globalPos())
         pos = pos.x(), pos.y()
 
+        vispy_event = None
         if t == QtCore.Qt.NativeGestureType.BeginNativeGesture:
-            self._vispy_canvas.events.touch(
+            vispy_event = self._vispy_canvas.events.touch(
                 type='gesture_begin',
                 pos=_get_event_xy(ev),
+                modifiers=self._modifiers(ev),
             )
         elif t == QtCore.Qt.NativeGestureType.EndNativeGesture:
             self._native_touch_total_rotation = []
             self._native_touch_total_scale = []
-            self._vispy_canvas.events.touch(
+            vispy_event = self._vispy_canvas.events.touch(
                 type='gesture_end',
                 pos=_get_event_xy(ev),
+                modifiers=self._modifiers(ev),
             )
         elif t == QtCore.Qt.NativeGestureType.RotateNativeGesture:
             angle = ev.value()
@@ -592,12 +614,13 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
             )
             self._native_gesture_rotation_values.append(angle)
             total_rotation_angle = math.fsum(self._native_gesture_rotation_values)
-            self._vispy_canvas.events.touch(
+            vispy_event = self._vispy_canvas.events.touch(
                 type="gesture_rotate",
                 pos=pos,
                 rotation=angle,
                 last_rotation=last_angle,
                 total_rotation_angle=total_rotation_angle,
+                modifiers=self._modifiers(ev),
             )
         elif t == QtCore.Qt.NativeGestureType.ZoomNativeGesture:
             scale = ev.value()
@@ -608,12 +631,13 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
             )
             self._native_gesture_scale_values.append(scale)
             total_scale_factor = math.fsum(self._native_gesture_scale_values)
-            self._vispy_canvas.events.touch(
+            vispy_event = self._vispy_canvas.events.touch(
                 type="gesture_zoom",
                 pos=pos,
                 last_scale=last_scale,
                 scale=scale,
                 total_scale_factor=total_scale_factor,
+                modifiers=self._modifiers(ev),
             )
         # QtCore.Qt.NativeGestureType.PanNativeGesture
         # Qt6 docs seem to imply this is only supported on Wayland but I have
@@ -622,6 +646,11 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
         # On macOS, more fingers are usually swallowed by the OS (by spaces,
         # mission control, etc.).
 
+        # If vispy did not handle the event, clear the accept parameter of the qt event
+        # Note that some handlers return None, this is equivalent to not handling the event
+        if vispy_event is None or not vispy_event.handled:
+            ev.ignore()
+
     def event(self, ev):
         out = super(QtBaseCanvasBackend, self).event(ev)
 
@@ -644,7 +673,10 @@ class QtBaseCanvasBackend(BaseCanvasBackend):
         else:
             key = None
         mod = self._modifiers(ev)
-        func(native=ev, key=key, text=str(ev.text()), modifiers=mod)
+        vispy_event = func(native=ev, key=key, text=str(ev.text()), modifiers=mod)
+        # If vispy did not handle the event, clear the accept parameter of the qt event
+        if not vispy_event.handled:
+            ev.ignore()
 
     def _modifiers(self, event):
         # Convert the QT modifier state into a tuple of active modifier keys.
@@ -771,7 +803,10 @@ class CanvasBackendEgl(QtBaseCanvasBackend, QWidget):
 
     def resizeEvent(self, event):
         w, h = event.size().width(), event.size().height()
-        self._vispy_canvas.events.resize(size=(w, h))
+        vispy_event = self._vispy_canvas.events.resize(size=(w, h))
+        # If vispy did not handle the event, clear the accept parameter of the qt event
+        if not vispy_event.handled:
+            event.ignore()
 
     def paintEvent(self, event):
         self._vispy_canvas.events.draw(region=None)

vispy/color/colormap.py

@@ -5,9 +5,10 @@
 from __future__ import division  # just to be safe...
 import warnings
 
+import re
 import numpy as np
 
-from .color_array import ColorArray
+from .color_array import ColorArray, Color
 from ..ext.cubehelix import cubehelix
 from hsluv import hsluv_to_rgb
 from ..util.check_environment import has_matplotlib
@@ -158,11 +159,12 @@ def _glsl_mix(controls=None, colors=None, texture_map_data=None):
     LUT[:, 0, 2] = np.interp(x, controls, c_rgba[:, 2])
     LUT[:, 0, 3] = np.interp(x, controls, c_rgba[:, 3])
 
-    s2 = "uniform sampler2D texture2D_LUT;"
-    s = "{\n return texture2D(texture2D_LUT, \
-          vec2(0.0, clamp(t, 0.0, 1.0)));\n} "
-
-    return "%s\nvec4 colormap(float t) {\n%s\n}" % (s2, s)
+    return """
+    uniform sampler2D texture2D_LUT;
+    vec4 colormap(float t) {
+        return texture2D(texture2D_LUT, vec2(0.0, clamp(t, 0.0, 1.0)));
+    }
+    """
 
 
 def _glsl_step(controls=None, colors=None, texture_map_data=None):
@@ -192,11 +194,12 @@ def _glsl_step(controls=None, colors=None, texture_map_data=None):
     colors_rgba = ColorArray(colors[:])._rgba
     LUT[:, 0, :] = colors_rgba[j]
 
-    s2 = "uniform sampler2D texture2D_LUT;"
-    s = "{\n return texture2D(texture2D_LUT, \
-           vec2(0.0, clamp(t, 0.0, 1.0)));\n} "
-
-    return "%s\nvec4 colormap(float t) {\n%s\n}" % (s2, s)
+    return """
+    uniform sampler2D texture2D_LUT;
+    vec4 colormap(float t) {
+        return texture2D(texture2D_LUT, vec2(0.0, clamp(t, 0.0, 1.0)));
+    }
+    """
 
 
 # Mini GLSL template system for colors.
@@ -219,6 +222,12 @@ class BaseColormap(object):
     ----------
     colors : list of lists, tuples, or ndarrays
         The control colors used by the colormap (shape = (ncolors, 4)).
+    bad_color : None | array-like
+        The color mapping for NaN values.
+    high_color : None | array-like
+        The color mapping for values greater than or equal to 1.
+    low_color : None | array-like
+        The color mapping for values less than or equal to 0.
 
     Notes
     -----
@@ -234,6 +243,9 @@ class BaseColormap(object):
 
     # Control colors used by the colormap.
     colors = None
+    bad_color = None
+    high_color = None
+    low_color = None
 
     # GLSL string with a function implementing the color map.
     glsl_map = None
@@ -242,7 +254,7 @@ class BaseColormap(object):
     # for luminance to RGBA conversion.
     texture_map_data = None
 
-    def __init__(self, colors=None):
+    def __init__(self, colors=None, *, bad_color=None, low_color=None, high_color=None):
         # Ensure the colors are arrays.
         if colors is not None:
             self.colors = colors
@@ -252,6 +264,51 @@ class BaseColormap(object):
         if len(self.colors) > 0:
             self.glsl_map = _process_glsl_template(self.glsl_map,
                                                    self.colors.rgba)
+        if high_color is not None:
+            self.high_color = Color(high_color)
+            self._set_high_color_glsl()
+        if low_color is not None:
+            self.low_color = Color(low_color)
+            self._set_low_color_glsl()
+
+        self.bad_color = Color((0, 0, 0, 0) if bad_color is None else bad_color)
+        self._set_bad_color_glsl()
+
+    def _set_bad_color_glsl(self):
+        """Set the color mapping for NaN values."""
+        r, g, b, a = self.bad_color.rgba
+
+        bad_color_glsl = f"""
+        // Map NaN to bad_color
+        if (!(t <= 0.0 || 0.0 <= t)) {{
+            return vec4({r:.3f}, {g:.3f}, {b:.3f}, {a:.3f});
+        }}"""
+
+        self.glsl_map = re.sub(r'float t\) \{', f'float t) {{{bad_color_glsl}', self.glsl_map)
+
+    def _set_high_color_glsl(self):
+        """Set the color mapping for values greater than or equal to max clim."""
+        r, g, b, a = self.high_color.rgba
+
+        high_color_glsl = f"""
+        // Map high_color
+        if (1 - t <= 1e-12) {{ // use epsilon to work around numerical imprecision
+            return vec4({r:.3f}, {g:.3f}, {b:.3f}, {a:.3f});
+        }}"""
+
+        self.glsl_map = re.sub(r'float t\) \{', f'float t) {{{high_color_glsl}', self.glsl_map)
+
+    def _set_low_color_glsl(self):
+        """Set the color mapping for values less than or equal to min clim."""
+        r, g, b, a = self.low_color.rgba
+
+        low_color_glsl = f"""
+        // Map low_color
+        if (t <= 1e-12) {{ // use epsilon to work around numerical imprecision
+            return vec4({r:.3f}, {g:.3f}, {b:.3f}, {a:.3f});
+        }}"""
+
+        self.glsl_map = re.sub(r'float t\) \{', f'float t) {{{low_color_glsl}', self.glsl_map)
 
     def map(self, item):
         """Return a rgba array for the requested items.
@@ -281,6 +338,15 @@ class BaseColormap(object):
         """
         raise NotImplementedError()
 
+    def _map_edge_case_colors(self, param, colors):
+        """Apply special mapping to edge cases (NaN and max/min clim)."""
+        colors = np.where(np.isnan(param.reshape(-1, 1)), self.bad_color.rgba, colors)
+        if self.high_color is not None:
+            colors = np.where((param == 1).reshape(-1, 1), self.high_color.rgba, colors)
+        if self.low_color is not None:
+            colors = np.where((param == 0).reshape(-1, 1), self.low_color.rgba, colors)
+        return colors
+
     def texture_lut(self):
         """Return a texture2D object for LUT after its value is set. Can be None."""
         return None
@@ -368,6 +434,12 @@ class Colormap(BaseColormap):
         be 'zero'.
         If 'linear', ncontrols = ncolors (one color per control point).
         If 'zero', ncontrols = ncolors+1 (one color per bin).
+    bad_color : None | array-like
+        The color mapping for NaN values.
+    high_color : None | array-like
+        The color mapping for values greater than or equal to 1.
+    low_color : None | array-like
+        The color mapping for values less than or equal to 0.
 
     Examples
     --------
@@ -379,7 +451,8 @@ class Colormap(BaseColormap):
 
     """
 
-    def __init__(self, colors, controls=None, interpolation='linear'):
+    def __init__(self, colors, controls=None, interpolation='linear', *,
+                 bad_color=None, low_color=None, high_color=None):
         self.interpolation = interpolation
         ncontrols = self._ncontrols(len(colors))
         # Default controls.
@@ -391,7 +464,8 @@ class Colormap(BaseColormap):
         self.texture_map_data = np.zeros((LUT_len, 1, 4), dtype=np.float32)
         self.glsl_map = self._glsl_map_generator(self._controls, colors,
                                                  self.texture_map_data)
-        super(Colormap, self).__init__(colors)
+        super(Colormap, self).__init__(colors, bad_color=bad_color,
+                                       high_color=high_color, low_color=low_color)
 
     @property
     def interpolation(self):
@@ -428,7 +502,8 @@ class Colormap(BaseColormap):
         colors : list
             List of rgba colors.
         """
-        return self._map_function(self.colors.rgba, x, self._controls)
+        colors = self._map_function(self.colors.rgba, x, self._controls)
+        return self._map_edge_case_colors(x, colors)
 
     def texture_lut(self):
         """Return a texture2D object for LUT after its value is set. Can be None."""
@@ -540,7 +615,8 @@ class _Fire(BaseColormap):
         a, b, d = self.colors.rgba
         c = _mix_simple(a, b, t)
         e = _mix_simple(b, d, t**2)
-        return _mix_simple(c, e, t)
+        colors = np.atleast_2d(_mix_simple(c, e, t))
+        return self._map_edge_case_colors(t, colors)
 
 
 class _Grays(BaseColormap):
@@ -551,10 +627,8 @@ class _Grays(BaseColormap):
     """
 
     def map(self, t):
-        if isinstance(t, np.ndarray):
-            return np.hstack([t, t, t, np.ones(t.shape)]).astype(np.float32)
-        else:
-            return np.array([t, t, t, 1.0], dtype=np.float32)
+        colors = np.c_[t, t, t, np.ones(t.shape)]
+        return self._map_edge_case_colors(t, colors)
 
 
 class _Ice(BaseColormap):
@@ -565,11 +639,8 @@ class _Ice(BaseColormap):
     """
 
     def map(self, t):
-        if isinstance(t, np.ndarray):
-            return np.hstack([t, t, np.ones(t.shape),
-                              np.ones(t.shape)]).astype(np.float32)
-        else:
-            return np.array([t, t, 1.0, 1.0], dtype=np.float32)
+        colors = np.c_[t, t, np.ones(t.shape), np.ones(t.shape)]
+        return self._map_edge_case_colors(t, colors)
 
 
 class _Hot(BaseColormap):
@@ -586,7 +657,8 @@ class _Hot(BaseColormap):
     def map(self, t):
         rgba = self.colors.rgba
         smoothed = smoothstep(rgba[0, :3], rgba[1, :3], t)
-        return np.hstack((smoothed, np.ones((len(t), 1))))
+        colors = np.hstack((smoothed, np.ones((len(t), 1))))
+        return self._map_edge_case_colors(t, colors)
 
 
 class _Winter(BaseColormap):
@@ -600,9 +672,15 @@ class _Winter(BaseColormap):
     """
 
     def map(self, t):
-        return _mix_simple(self.colors.rgba[0],
+        colors = _mix_simple(self.colors.rgba[0],
                            self.colors.rgba[1],
                            np.sqrt(t))
+        return self._map_edge_case_colors(t, colors)
+
+
+class _HiLo(_Grays):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs, low_color='blue', high_color='red')
 
 
 class SingleHue(Colormap):
@@ -1089,6 +1167,7 @@ _colormaps = dict(
     husl=HSLuv(),
     diverging=Diverging(),
     RdYeBuCy=RedYellowBlueCyan(),
+    HiLo=_HiLo(),
 )
 
 

vispy/color/tests/test_color.py

@@ -3,7 +3,7 @@
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
 import numpy as np
-from numpy.testing import assert_array_equal, assert_allclose
+from numpy.testing import assert_array_equal, assert_array_almost_equal, assert_allclose
 
 from vispy.color import (Color, ColorArray, get_color_names,
                          Colormap,
@@ -349,4 +349,30 @@ def test_normalize():
     assert_allclose([y.min(), y.max()], [0.2975, 1-0.2975], 1e-1, 1e-1)
 
 
+def test_colormap_bad_color():
+    """Test NaN handling."""
+    red = (1, 0, 0, 1)
+    white = (1, 1, 1, 1)
+    green = (0, 1, 0, 1)
+    cm = Colormap([white, green], bad_color=red)
+    assert_array_equal(cm[0].rgba, [white])
+    assert_array_equal(cm[1].rgba, [green])
+
+
+def test_colormap_high_low_color():
+    """Test handling of clim extremes."""
+    hilo = get_colormap('HiLo')
+    white = (1, 1, 1, 1)
+    gray = (0.5, 0.5, 0.5, 1)
+    black = (0, 0, 0, 1)
+    red = (1, 0, 0, 1)
+    blue = (0, 0, 1, 1)
+
+    assert_array_equal(hilo[0].rgba, [blue])
+    assert_array_almost_equal(hilo[0.000001].rgba, [black])
+    assert_array_equal(hilo[0.5].rgba, [gray])
+    assert_array_almost_equal(hilo[0.999999].rgba, [white])
+    assert_array_equal(hilo[1].rgba, [red])
+
+
 run_tests_if_main()

vispy/ext/cocoapy.py

@@ -18,26 +18,6 @@ else:
     string_types = basestring,  # noqa
 
 
-# handle dlopen cache changes in macOS 11 (Big Sur)
-# ref https://stackoverflow.com/questions/63475461/unable-to-import-opengl-gl-in-python-on-macos
-try:
-    import OpenGL.GL   # noqa
-except ImportError:
-    # print('Drat, patching for Big Sur')
-    orig_util_find_library = util.find_library
-
-    def new_util_find_library(name):
-        res = orig_util_find_library(name)
-        if res:
-            return res
-        lut = {
-            'objc': 'libobjc.dylib',
-            'quartz': 'Quartz.framework/Quartz'
-        }
-        return lut.get(name, name+'.framework/'+name)
-    util.find_library = new_util_find_library
-
-
 # Based on Pyglet code
 
 ##############################################################################
@@ -1285,7 +1265,7 @@ NSApplicationActivationPolicyProhibited = 2
 
 # QUARTZ / COREGRAPHICS
 
-quartz = cdll.LoadLibrary(util.find_library('quartz'))
+quartz = cdll.LoadLibrary(util.find_library('Quartz'))
 
 CGDirectDisplayID = c_uint32     # CGDirectDisplay.h
 CGError = c_int32                # CGError.h

vispy/geometry/meshdata.py

@@ -386,7 +386,9 @@ class MeshData(object):
         if indexed is None:
             return self._vertex_normals
         elif indexed == 'faces':
-            return self._vertex_normals[self.get_faces()]
+            if self._vertex_normals_indexed_by_faces is None:
+                self._vertex_normals_indexed_by_faces = self._vertex_normals[self.get_faces()]
+            return self._vertex_normals_indexed_by_faces
 
     def get_vertex_colors(self, indexed=None):
         """Get vertex colors

vispy/geometry/tests/test_triangulation.py

@@ -2,6 +2,7 @@ import sys
 from unittest import SkipTest
 
 import numpy as np
+import pytest
 from numpy.testing import assert_array_almost_equal
 
 from vispy.testing import run_tests_if_main
@@ -503,4 +504,91 @@ def test_edge_event():
     t.triangulate()
 
 
+def test_triangulate_triangle():
+    pts = np.array([
+        [4, 4],
+        [1, 4],
+        [1, 2],
+    ])
+    t = _triangulation_from_points(pts)
+
+    t.triangulate()
+
+    assert len(t.tris) == 1
+    _assert_triangle_pts_in_input(t, pts)
+
+
+def test_triangulate_square():
+    pts = np.array([
+        [4, 4],
+        [1, 4],
+        [1, 2],
+        [4, 2],
+    ])
+    t = _triangulation_from_points(pts)
+
+    t.triangulate()
+
+    assert len(t.tris) == 2
+    _assert_triangle_pts_in_input(t, pts)
+
+
+def test_triangulate_triangle_with_collinear_pts():
+    pts = np.array([
+        [4, 4],
+        [3, 4],
+        [1, 4],
+        [1, 2],
+    ])
+    t = _triangulation_from_points(pts)
+
+    t.triangulate()
+
+    assert len(t.tris) in (1, 2)
+    _assert_triangle_pts_in_input(t, pts)
+
+
+def test_triangulate_collinear_path():
+    pts = np.array([
+        [4, 4],
+        [3, 4],
+        [1, 4],
+    ])
+    t = _triangulation_from_points(pts)
+
+    t.triangulate()
+
+    assert len(t.tris) == 0
+    _assert_triangle_pts_in_input(t, pts)
+
+
+@pytest.mark.xfail(reason="See https://github.com/vispy/vispy/issues/2247")
+def test_triangulate_collinear_path_with_repeat():
+    pts = np.array([
+        [4, 4],
+        [3, 4],
+        [1, 4],
+        [4, 4],
+        [1, 2],
+    ])
+    t = _triangulation_from_points(pts)
+
+    t.triangulate()
+
+    assert len(t.tris) == 0
+    _assert_triangle_pts_in_input(t, pts)
+
+
+def _assert_triangle_pts_in_input(t, input_pts):
+    pt_indices_in_tris = set(v for tri in t.tris for v in tri)
+    for i in pt_indices_in_tris:
+        assert np.any(np.all(t.pts[i] == input_pts, axis=1))
+
+
+def _triangulation_from_points(points):
+    inds = np.arange(points.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+    return T(points, edges)
+
+
 run_tests_if_main()

vispy/geometry/triangulation.py

@@ -99,7 +99,7 @@ class Triangulation(object):
         self._tops = self.edges.max(axis=1)
         self._bottoms = self.edges.min(axis=1)
 
-        # inintialize sweep front
+        # initialize sweep front
         # values in this list are indexes into self.pts
         self._front = [0, 2, 1]
 
@@ -185,7 +185,7 @@ class Triangulation(object):
                 for j in self._bottoms[self._tops == i]:
                     # Make sure edge (j, i) is present in mesh
                     # because edge event may have created a new front list
-                    self._edge_event(i, j)
+                    self._edge_event(i, int(j))
                     front = self._front
 
         self._finalize()
@@ -203,7 +203,7 @@ class Triangulation(object):
         while k < idx-1:
             # if edges lie in counterclockwise direction, then signed area
             # is positive
-            if self._iscounterclockwise(front[k], front[k+1], front[k+2]):
+            if self._orientation((front[k], front[k+1]), front[k+2]) < 0:
                 self._add_tri(front[k], front[k+1], front[k+2])
                 front.pop(k+1)
                 idx -= 1
@@ -398,7 +398,7 @@ class Triangulation(object):
 
                     upper_polygon.append(front[front_index+front_dir])
 
-        # (iii) triangluate empty areas
+        # (iii) triangulate empty areas
 
         for polygon in [lower_polygon, upper_polygon]:
             dist = self._distances_from_line((i, j), polygon)
@@ -673,13 +673,6 @@ class Triangulation(object):
         d = (a + c - b) / ((4 * a * c)**0.5)
         return d
 
-    def _iscounterclockwise(self, a, b, c):
-        # Check if the points lie in counter-clockwise order or not
-        A = self.pts[a]
-        B = self.pts[b]
-        C = self.pts[c]
-        return _cross_2d(B - A, C - B) > 0
-
     def _edges_intersect(self, edge1, edge2):
         """Return 1 if edges intersect completely (endpoints excluded)"""
         h12 = self._intersect_edge_arrays(self.pts[np.array(edge1)],
@@ -748,7 +741,7 @@ class Triangulation(object):
         # sanity check
         assert a != b and b != c and c != a
 
-        # ignore flat tris
+        # ignore tris with duplicate points
         pa = self.pts[a]
         pb = self.pts[b]
         pc = self.pts[c]
@@ -761,8 +754,13 @@ class Triangulation(object):
                 raise Exception("Cannot add %s; already have %s" %
                                 ((a, b, c), t))
 
+        # ignore lines
+        orientation = self._orientation((a, b), c)
+        if orientation == 0:
+            return
+
         # TODO: should add to edges_lookup after legalization??
-        if self._iscounterclockwise(a, b, c):
+        if orientation < 0:
             assert (a, b) not in self._edges_lookup
             assert (b, c) not in self._edges_lookup
             assert (c, a) not in self._edges_lookup