vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/geometry/tests/test_triangulation.py

@@ -0,0 +1,506 @@
+import sys
+from unittest import SkipTest
+
+import numpy as np
+from numpy.testing import assert_array_almost_equal
+
+from vispy.testing import run_tests_if_main
+from vispy.geometry.triangulation import Triangulation as T
+
+
+def assert_array_eq(a, b):
+    assert a.shape == b.shape
+    assert a.dtype == b.dtype
+    mask = np.isnan(a)
+    assert np.all(np.isnan(b[mask]))
+    assert np.all(a[~mask] == b[~mask])
+
+
+def test_intersect_edge_arrays():
+    global t
+    pts = np.array([
+        [0., 0.],
+        [0., 10.],
+        [5., 0.],
+        [-5., 0.],
+        [-1., 11.],
+        [1., 9.],
+    ])
+    edges = np.array([
+        [0, 1],
+        [2, 3],
+        [0, 3],
+        [4, 5],
+        [4, 1],
+        [0, 1],
+    ])
+
+    lines = pts[edges]
+    t = T(pts, edges)
+
+    # intersect array of one edge with a array of many edges
+    intercepts = t._intersect_edge_arrays(lines[0:1], lines[1:])
+    expect = np.array([0.5, 0.0, 0.5, 1.0, np.nan])
+    assert_array_eq(intercepts, expect)
+
+    # intersect every line with every line
+    intercepts = t._intersect_edge_arrays(lines[:, np.newaxis, ...],
+                                          lines[np.newaxis, ...])
+    for i in range(lines.shape[0]):
+        int2 = t._intersect_edge_arrays(lines[i], lines)
+        assert_array_eq(intercepts[i], int2)
+
+
+def test_edge_intersections():
+    global t
+    pts = np.array([
+        [0, 0],
+        [1, 0],
+        [1, 1],
+        [0, 1],
+        [0, 0.5],  # three edges intersect here
+        [2, 0.5],
+        [-1, 0.2],
+        [2, 0.8],
+        [-1, 1],
+        [0, 0.5],
+    ])
+    edges = np.array([
+        [0, 1],
+        [1, 2],
+        [2, 3],
+        [3, 0],
+        [4, 5],
+        [6, 7],
+        [8, 9],
+    ])
+
+    t = T(pts, edges)
+
+    # first test find_edge_intersections
+    cuts = t._find_edge_intersections()
+    expect = {
+        0: [],
+        1: [(0.5, [1., 0.5]),
+            (0.6, [1., 0.6])],
+        2: [],
+        3: [(0.5, [0., 0.5]),
+            (0.6, [0., 0.4])],
+        4: [(0.25, [0.5, 0.5]),
+            (0.5, [1., 0.5])],
+        5: [(1./3., [0., 0.4]),
+            (0.5, [0.5, 0.5]),
+            (2./3., [1., 0.6])],
+    }
+
+    assert len(expect) == len(cuts)
+    for k, v in expect.items():
+        assert len(v) == len(cuts[k])
+        for i, ecut in enumerate(v):
+            vcut = cuts[k][i]
+            assert len(vcut) == len(ecut)
+            for j in range(len(vcut)):
+                assert_array_almost_equal(np.array(ecut[j]), np.array(vcut[j]))
+
+    # next test that we can split the edges correctly
+    t._split_intersecting_edges()
+    pts = np.array([[0., 0.],
+                    [1., 0.],
+                    [1., 1.],
+                    [0., 1.],
+                    [0., 0.5],
+                    [2., 0.5],
+                    [-1., 0.2],
+                    [2., 0.8],
+                    [-1., 1.],
+                    [0., 0.5],
+                    [1., 0.5],
+                    [1., 0.6],
+                    [0., 0.5],
+                    [0., 0.4],
+                    [0.5, 0.5],
+                    [1., 0.5],
+                    [0., 0.4],
+                    [0.5, 0.5],
+                    [1., 0.6]])
+    edges = np.array([[0, 1],
+                      [1, 10],
+                      [2, 3],
+                      [3, 12],
+                      [4, 14],
+                      [6, 16],
+                      [8, 9],
+                      [10, 11],
+                      [11, 2],
+                      [12, 13],
+                      [13, 0],
+                      [14, 15],
+                      [15, 5],
+                      [16, 17],
+                      [17, 18],
+                      [18, 7]])
+
+    if sys.version[0] == '3':
+        raise SkipTest('Triangulation differences on Py3k')
+    assert_array_almost_equal(pts, t.pts)
+    assert np.all(edges == t.edges)
+
+    # Test _nearly_ parallel lines.
+    pts = np.array([[0., 0.],
+                    [1.62434542, 0.],
+                    [1.62434542, -0.61175638],
+                    [1.09617364, -0.61175638]])
+
+    edges = np.array([[0, 1], [1, 2], [2, 3], [3, 0]])
+    t = T(pts, edges)
+    for edge, cuts in t._find_edge_intersections().items():
+        assert len(cuts) == 0
+
+
+def test_merge_duplicate_points():
+    global t
+    pts = np.array([
+        [0, 0],
+        [1, 1],
+        [0.1, 0.7],
+        [2, 3],
+        [0, 0],
+        [0.1, 0.7],
+        [5, 6],
+    ])
+    edges = np.array([
+        [0, 6],
+        [1, 5],
+        [2, 4],
+        [3, 6],
+        [4, 5],
+    ])
+
+    t = T(pts, edges)
+    t._merge_duplicate_points()
+
+    pts = np.array([
+        [0, 0],
+        [1, 1],
+        [0.1, 0.7],
+        [2, 3],
+        [5, 6],
+    ])
+    edges = np.array([
+        [0, 4],
+        [1, 2],
+        [2, 0],
+        [3, 4],
+        [0, 2],
+    ])
+    assert np.allclose(t.pts, pts)
+    assert np.all(t.edges == edges)
+
+
+def test_initialize():
+    # check points are correctly sorted
+    # check artificial points are outside bounds of all others
+    # check tops / bottoms
+    pass
+
+
+def test_utility_methods():
+    global t
+    pts = np.array([
+        [0, 0],
+        [1, 0],
+        [2, 0],
+        [3, 0],
+        [1.5, 2],
+        [1.5, -2],
+    ])
+    edges = np.array([
+        [4, 5],  # edge cuts through triangle (1, 2, 4)
+    ])
+
+    t = T(pts, edges)
+    # skip initialization and just simulate being part-way through
+    # triangulation
+    for tri in [[0, 1, 4], [1, 2, 4], [2, 3, 4]]:
+        t._add_tri(*tri)
+
+    # find_cut_triangle
+    assert t._find_cut_triangle((4, 5)) == (4, 1, 2)
+
+    # orientation
+    assert t._orientation((4, 5), 0) == 1
+    assert t._orientation((4, 5), 1) == 1
+    assert t._orientation((4, 5), 2) == -1
+    assert t._orientation((4, 5), 3) == -1
+    assert t._orientation((4, 5), 4) == 0
+    assert t._orientation((4, 5), 5) == 0
+
+    # adjacent_tri
+    assert t._adjacent_tri((1, 4), 0) == (4, 1, 2)
+    assert t._adjacent_tri((0, 4), 1) is None
+    assert t._adjacent_tri((1, 4), (1, 4, 0)) == (4, 1, 2)
+    assert t._adjacent_tri((0, 4), (1, 4, 0)) is None
+    try:
+        t._adjacent_tri((1, 4), 5)
+    except RuntimeError:
+        pass
+    else:
+        raise Exception("Expected RuntimeError.")
+
+    # edges_intersect
+    assert not t._edges_intersect((0, 1), (1, 2))
+    assert not t._edges_intersect((0, 2), (1, 2))
+    assert t._edges_intersect((4, 5), (1, 2))
+
+    # is_constraining_edge
+    assert t._is_constraining_edge((4, 5))
+    assert t._is_constraining_edge((5, 4))
+    assert not t._is_constraining_edge((3, 5))
+    assert not t._is_constraining_edge((3, 2))
+
+
+def test_projection():
+    pts = np.array([[0, 0],
+                    [5, 0],
+                    [1, 2],
+                    [3, 4]])
+    t = T(pts, np.zeros((0, 2)))
+
+    a, b, c, d = pts
+    assert np.allclose(t._projection(a, c, b), [1, 0])
+    assert np.allclose(t._projection(b, c, a), [1, 0])
+    assert np.allclose(t._projection(a, d, b), [3, 0])
+    assert np.allclose(t._projection(b, d, a), [3, 0])
+    assert np.allclose(t._projection(a, b, c), [1, 2])
+    assert np.allclose(t._projection(c, b, a), [1, 2])
+
+
+def test_random():
+    # Just test that these triangulate without exception.
+    # TODO: later on, we can turn this same test into an image comparison
+    # with Polygon.
+    N = 10
+    np.random.seed(0)
+
+    for i in range(4):
+        pts = np.random.normal(size=(N, 2))
+        edges = np.zeros((N, 2), dtype=int)
+        edges[:, 0] = np.arange(N)
+        edges[:, 1] = np.arange(1, N+1) % N
+
+        t = T(pts, edges)
+        t.triangulate()
+
+    theta = np.linspace(0, 2*np.pi, 11)[:-1]
+    pts = np.hstack([np.cos(theta)[:, np.newaxis],
+                     np.sin(theta)[:, np.newaxis]])
+    pts[::2] *= 0.4
+    edges = np.empty((pts.shape[0], 2), dtype=np.uint)
+    edges[:, 0] = np.arange(pts.shape[0])
+    edges[:, 1] = edges[:, 0] + 1
+    edges[-1, 1] = 0
+    t = T(pts, edges)
+    t.triangulate()
+
+    # much larger test
+    # this should pass, but takes forever..
+    # N = 4000
+    # pts = np.random.normal(size=(N, 2))
+    # pts = np.cumsum(pts, axis=0)
+    # edges = np.zeros((N, 2), dtype=int)
+    # edges[:,0] = np.arange(N)
+    # edges[:,1] = np.arange(1,N+1) % N
+
+    # t = T(pts, edges)
+    # t.triangulate()
+
+
+def test_orthogonal():
+    # make lines that are entirely vertical / horizontal
+    np.random.seed(1)
+    N = 100
+    pts = [[0, 0]]
+    for i in range(N - 1):
+        p = pts[-1][:]
+        p[i % 2] += np.random.normal()
+        pts.append(p)
+    pts = np.array(pts)
+    edges = np.zeros((N, 2), dtype=int)
+    edges[:, 0] = np.arange(N)
+    edges[:, 1] = np.arange(1, N + 1) % N
+
+    t = T(pts, edges)
+    t.triangulate()
+
+
+def test_edge_event():
+    # mode 1
+    pts = np.array([[0, 0],
+                    [5, -10],
+                    [10, 0],
+                    [6, -5],
+                    [5, 5],
+                    ])
+    inds = np.arange(pts.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+
+    t = T(pts, edges)
+    t.triangulate()
+
+    t = T(pts * [-1, 1], edges)
+    t.triangulate()
+
+    # mode 2
+    pts = np.array([[0, 0],
+                    [10, 0],
+                    [20, 0],
+                    [5, 11],
+                    ])
+    inds = np.arange(pts.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+
+    t = T(pts, edges)
+    t.triangulate()
+
+    t = T(pts * [-1, 1], edges)
+    t.triangulate()
+
+    # mode 1, 2
+    pts = np.array([[0, 0],
+                    [10, 0],
+                    [20, 0],
+                    [5, 11],
+                    [9, 10],
+                    [0, 20],
+                    ])
+    inds = np.arange(pts.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+
+    t = T(pts, edges)
+    t.triangulate()
+
+    t = T(pts * [-1, 1], edges)
+    t.triangulate()
+
+    # mode 2, 1
+    pts = np.array([[0, 0],
+                    [10, 0],
+                    [20, 0],
+                    [15, 8],
+                    [15, 1],
+                    [-5, 10],
+                    ])
+    inds = np.arange(pts.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+
+    t = T(pts, edges)
+    t.triangulate()
+
+    t = T(pts * [-1, 1], edges)
+    t.triangulate()
+
+    # mode 2, 1 with many triangles
+    pts = np.array([[0, 10],
+                    [2, 8],
+                    [4, 6],
+                    [6, 4],
+                    [8, 2],
+                    [10, 0],
+
+                    [20, 5],
+                    [20, 20],
+
+                    [2, 13],
+                    [4, 11],
+                    [6, 9],
+                    [8, 7],
+                    [10, 5],
+
+                    [10, 1],
+                    [0, 15],
+                    ])
+    inds = np.arange(pts.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+
+    t = T(pts, edges)
+    t.triangulate()
+
+    t = T(pts * [-1, 1], edges)
+    t.triangulate()
+
+    # mode 1, 2, 1, 2, 1
+    pts = np.array([[0, 10],
+                    [2, 9],
+                    [4, 8],
+                    [6, 7],
+                    [8, 6],
+                    [10, 5],
+
+                    [20, 5],
+                    [20, 20],
+
+                    [2, 11],
+                    [19, 19],
+                    [6, 9],
+                    [19, 18],
+                    [10, 7],
+
+                    [11, 5.1],
+                    [0, 11.1],
+                    ])
+    inds = np.arange(pts.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+
+    t = T(pts, edges)
+    t.triangulate()
+
+    t = T(pts * [-1, 1], edges)
+    t.triangulate()
+
+    # mode 2, 1, 2, 1
+    pts = np.array([[0, 10],
+                    [2, 9],
+                    [4, 8],
+                    [6, 7],
+                    [8, 6],
+                    [10, 5],
+
+                    [20, 5],
+                    [20, 20],
+
+                    [6, 9],
+                    [19, 18],
+                    [10, 7],
+
+                    [11, 5.1],
+                    [0, 11.1],
+                    ])
+    inds = np.arange(pts.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+
+    t = T(pts, edges)
+    t.triangulate()
+
+    t = T(pts * [-1, 1], edges)
+    t.triangulate()
+
+    # 1, 2  upper/lower polygon order check
+    pts = np.array([[-5, 0],
+                    [-3, 0],
+                    [10, 0],
+                    [15, 15],
+                    [4, 9],
+                    [6, 8.8],
+                    [9, 10],
+                    ])
+    inds = np.arange(pts.shape[0])[:, np.newaxis]
+    edges = np.hstack([inds, np.roll(inds, -1)])
+
+    t = T(pts, edges)
+    t.triangulate()
+
+    t = T(pts * [-1, 1], edges)
+    t.triangulate()
+
+
+run_tests_if_main()

vispy/geometry/torusknot.py

@@ -0,0 +1,142 @@
+from __future__ import division
+
+import numpy as np
+from math import gcd
+
+
+class TorusKnot(object):
+    """Representation of a torus knot or link.
+
+    A torus knot is one that can be drawn on the surface of a
+    torus. It is parameterised by two integers p and q as below; in
+    fact this returns a single knot (a single curve) only if p and q
+    are coprime, otherwise it describes multiple linked curves.
+
+    Parameters
+    ----------
+    p : int
+        The number of times the knot winds around the outside of the
+        torus. Defaults to 2.
+    q : int
+        The number of times the knot passes through the hole in the
+        centre of the torus. Defaults to 3.
+    num_points : int
+        The number of points in the returned piecewise linear
+        curve. If there are multiple curves (i.e. a torus link), this
+        is the number of points in *each* curve.  Defaults to 100.
+    major_radius : float
+        Distance from the center of the torus tube to the center of the torus.
+        Defaults to 10.
+    minor_radius : float
+        The radius of the torus tube. Defaults to 5.
+
+    """
+
+    def __init__(self, p=3, q=2, num_points=100, major_radius=10.,
+                 minor_radius=5.):
+        self._p = p
+        self._q = q
+        self._num_points = num_points
+        self._major_radius = major_radius
+        self._minor_radius = minor_radius
+
+        self._calculate_vertices()
+
+    def _calculate_vertices(self):
+        angles = np.linspace(0, 2*np.pi, self._num_points)
+
+        num_components = self.num_components
+
+        divisions = (np.max([self._q, self._p]) *
+                     np.min([self._q, self._p]) // self.num_components)
+        starting_angles = np.linspace(
+            0, 2*np.pi, divisions + 1)[
+            :num_components]
+        q = self._q / num_components
+        p = self._p / num_components
+
+        components = []
+        for starting_angle in starting_angles:
+            vertices = np.zeros((self._num_points, 3))
+            local_angles = angles + starting_angle
+            radii = (self._minor_radius * np.cos(q * angles) +
+                     self._major_radius)
+            vertices[:, 0] = radii * np.cos(p * local_angles)
+            vertices[:, 1] = radii * np.sin(p * local_angles)
+            vertices[:, 2] = (self._minor_radius * -1 *
+                              np.sin(q * angles))
+            components.append(vertices)
+
+        self._components = components
+
+    @property
+    def first_component(self):
+        """The vertices of the first component line of the torus knot or link."""
+        return self._components[0]
+
+    @property
+    def components(self):
+        """A list of the vertices in each line of the torus knot or link.
+        Even if p and q are coprime, this is a list with just one
+        entry.
+        """
+        return self._components
+
+    @property
+    def num_components(self):
+        """The number of component lines in the torus link. This is equal
+        to the greatest common divisor of p and q.
+        """
+        return gcd(self._p, self._q)
+
+    @property
+    def q(self):
+        """The q parameter of the torus knot or link."""
+        return self._q
+
+    @q.setter
+    def q(self, q):
+        self._q = q
+        self._calculate_vertices()
+
+    @property
+    def p(self):
+        """The p parameter of the torus knot or link."""
+        return self._p
+
+    @p.setter
+    def p(self, p):
+        self._p = p
+        self._calculate_vertices()
+
+    @property
+    def minor_radius(self):
+        """The minor radius of the torus."""
+        return self._minor_radius
+
+    @minor_radius.setter
+    def minor_radius(self, r):
+        self._minor_radius = r
+        self._calculate_vertices()
+
+    @property
+    def major_radius(self):
+        """The major radius of the torus."""
+        return self._major_radius
+
+    @major_radius.setter
+    def major_radius(self, r):
+        self._major_radius = r
+        self._calculate_vertices()
+
+    @property
+    def num_points(self):
+        """The number of points in the vertices returned for each knot/link
+        component
+        """
+        return self._num_points
+
+    @num_points.setter
+    def num_points(self, r):
+        self._num_points = r
+        self._calculate_vertices()