vispy 0.15.0__cp312-cp312-macosx_10_13_x86_64.whl

vispy/geometry/normals.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+import numpy as np
+
+
+def compact(vertices, indices, tolerance=1e-3):
+    """Compact vertices and indices within given tolerance"""
+    # Transform vertices into a structured array for np.unique to work
+    n = len(vertices)
+    V = np.zeros(n, dtype=[("pos", np.float32, 3)])
+    V["pos"][:, 0] = vertices[:, 0]
+    V["pos"][:, 1] = vertices[:, 1]
+    V["pos"][:, 2] = vertices[:, 2]
+
+    epsilon = 1e-3
+    decimals = int(np.log(epsilon)/np.log(1/10.))
+
+    # Round all vertices within given decimals
+    V_ = np.zeros_like(V)
+    X = V["pos"][:, 0].round(decimals=decimals)
+    X[np.where(abs(X) < epsilon)] = 0
+
+    V_["pos"][:, 0] = X
+    Y = V["pos"][:, 1].round(decimals=decimals)
+    Y[np.where(abs(Y) < epsilon)] = 0
+    V_["pos"][:, 1] = Y
+
+    Z = V["pos"][:, 2].round(decimals=decimals)
+    Z[np.where(abs(Z) < epsilon)] = 0
+    V_["pos"][:, 2] = Z
+
+    # Find the unique vertices AND the mapping
+    U, RI = np.unique(V_, return_inverse=True)
+
+    # Translate indices from original vertices into the reduced set (U)
+    indices = indices.ravel()
+    I_ = indices.copy().ravel()
+    for i in range(len(indices)):
+        I_[i] = RI[indices[i]]
+    I_ = I_.reshape(len(indices)//3, 3)
+
+    # Return reduced vertices set, transalted indices and mapping that allows
+    # to go from U to V
+    return U.view(np.float32).reshape(len(U), 3), I_, RI
+
+
+def normals(vertices, indices):
+    """Compute normals over a triangulated surface
+
+    Parameters
+    ----------
+    vertices : ndarray (n,3)
+        triangles vertices
+
+    indices : ndarray (p,3)
+        triangles indices
+    """
+    # Compact similar vertices
+    vertices, indices, mapping = compact(vertices, indices)
+
+    T = vertices[indices]
+    N = np.cross(T[:, 1] - T[:, 0], T[:, 2]-T[:, 0])
+    L = np.sqrt(np.sum(N * N, axis=1))
+    L[L == 0] = 1.0  # prevent divide-by-zero
+    N /= L[:, np.newaxis]
+    normals = np.zeros_like(vertices)
+    normals[indices[:, 0]] += N
+    normals[indices[:, 1]] += N
+    normals[indices[:, 2]] += N
+    L = np.sqrt(np.sum(normals*normals, axis=1))
+    L[L == 0] = 1.0
+    normals /= L[:, np.newaxis]
+
+    return normals[mapping]

vispy/geometry/parametric.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+import numpy as np
+from .normals import normals
+
+
+def surface(func, umin=0, umax=2 * np.pi, ucount=64, urepeat=1.0,
+            vmin=0, vmax=2 * np.pi, vcount=64, vrepeat=1.0):
+    """
+    Computes the parameterization of a parametric surface
+
+    func: function(u,v)
+        Parametric function used to build the surface
+    """
+    vtype = [('position', np.float32, 3),
+             ('texcoord', np.float32, 2),
+             ('normal', np.float32, 3)]
+    itype = np.uint32
+
+    # umin, umax, ucount = 0, 2*np.pi, 64
+    # vmin, vmax, vcount = 0, 2*np.pi, 64
+
+    vcount += 1
+    ucount += 1
+    n = vcount * ucount
+
+    Un = np.repeat(np.linspace(0, 1, ucount, endpoint=True), vcount)
+    Vn = np.tile(np.linspace(0, 1, vcount, endpoint=True), ucount)
+    U = umin + Un * (umax - umin)
+    V = vmin + Vn * (vmax - vmin)
+
+    vertices = np.zeros(n, dtype=vtype)
+    for i, (u, v) in enumerate(zip(U, V)):
+        vertices["position"][i] = func(u, v)
+
+    vertices["texcoord"][:, 0] = Un * urepeat
+    vertices["texcoord"][:, 1] = Vn * vrepeat
+
+    indices = []
+    for i in range(ucount - 1):
+        for j in range(vcount - 1):
+            indices.append(i * (vcount) + j)
+            indices.append(i * (vcount) + j + 1)
+            indices.append(i * (vcount) + j + vcount + 1)
+            indices.append(i * (vcount) + j + vcount)
+            indices.append(i * (vcount) + j + vcount + 1)
+            indices.append(i * (vcount) + j)
+    indices = np.array(indices, dtype=itype)
+    vertices["normal"] = normals(vertices["position"],
+                                 indices.reshape(len(indices)//3, 3))
+
+    return vertices, indices

vispy/geometry/polygon.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+import numpy as np
+
+from .triangulation import Triangulation
+
+
+class PolygonData(object):
+    """Polygon class for data handling
+
+    Parameters
+    ----------
+    vertices : (Nv, 3) array
+        Vertex coordinates. If faces is not specified, then this will instead
+        be interpreted as (Nf, 3, 3) array of coordinates.
+    edges : (Nv, 2) array
+        Constraining edges specified by vertex indices.
+    faces : (Nf, 3) array
+        Indexes into the vertex array.
+
+    Notes
+    -----
+    All arguments are optional.
+    """
+
+    def __init__(self, vertices=None, edges=None, faces=None):
+        self._vertices = vertices
+        self._edges = edges
+        self._faces = faces
+        self._convex_hull = None
+
+    @property
+    def faces(self):
+        """Return an array (Nf, 3) of vertex indexes, three per triangular
+        face in the mesh.
+
+        If faces have not been computed for this mesh, the function
+        computes them.
+        If no vertices or faces are specified, the function returns None.
+        """
+        if self._faces is None:
+            if self._vertices is None:
+                return None
+            self.triangulate()
+        return self._faces
+
+    @faces.setter
+    def faces(self, f):
+        """If vertices and faces are incompatible, this will generate vertices
+        from these faces and set them.
+        """
+        self._faces = f
+
+    @property
+    def vertices(self):
+        """Return an array (Nf, 3) of vertices.
+
+        If only faces exist, the function computes the vertices and
+        returns them.
+        If no vertices or faces are specified, the function returns None.
+        """
+        if self._faces is None:
+            if self._vertices is None:
+                return None
+            self.triangulate()
+        return self._vertices
+
+    @vertices.setter
+    def vertices(self, v):
+        """If vertices and faces are incompatible, this will generate faces
+        from these vertices and set them.
+        """
+        self._vertices = v
+
+    @property
+    def edges(self):
+        """Return an array (Nv, 2) of vertex indices.
+
+        If no vertices or faces are specified, the function returns None.
+        """
+        return self._edges
+
+    @edges.setter
+    def edges(self, e):
+        """Ensures that all edges are valid."""
+        self._edges = e
+
+    @property
+    def convex_hull(self):
+        """Return an array of vertex indexes representing the convex hull.
+
+        If faces have not been computed for this mesh, the function
+        computes them.
+        If no vertices or faces are specified, the function returns None.
+        """
+        if self._faces is None:
+            if self._vertices is None:
+                return None
+            self.triangulate()
+        return self._convex_hull
+
+    def triangulate(self):
+        """
+        Triangulates the set of vertices and stores the triangles in faces and
+        the convex hull in convex_hull.
+        """
+        npts = self._vertices.shape[0]
+        if np.any(self._vertices[0] != self._vertices[1]):
+            # start != end, so edges must wrap around to beginning.
+            edges = np.empty((npts, 2), dtype=np.uint32)
+            edges[:, 0] = np.arange(npts)
+            edges[:, 1] = edges[:, 0] + 1
+            edges[-1, 1] = 0
+        else:
+            # start == end; no wrapping required.
+            edges = np.empty((npts-1, 2), dtype=np.uint32)
+            edges[:, 0] = np.arange(npts)
+            edges[:, 1] = edges[:, 0] + 1
+
+        tri = Triangulation(self._vertices, edges)
+        tri.triangulate()
+        return tri.pts, tri.tris
+
+    def add_vertex(self, vertex):
+        """
+        Adds given vertex and retriangulates to generate new faces.
+
+        Parameters
+        ----------
+        vertex : array-like
+            The vertex to add.
+        """
+        raise NotImplementedError

vispy/geometry/rect.py

@@ -0,0 +1,210 @@
+import numpy as np
+
+
+class Rect(object):
+    """
+    Representation of a rectangular area in a 2D coordinate system.
+
+    Parameters
+    ----------
+    *args : arguments
+        Can be in the form `Rect(x, y, w, h)`, `Rect(pos, size)`, or
+        `Rect(Rect)`.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._pos = (0, 0)
+        self._size = (0, 0)
+
+        if len(args) == 1 and isinstance(args[0], Rect):
+            self._pos = args[0]._pos[:]
+            self._size = args[0]._size[:]
+        elif (len(args) == 1 and isinstance(args[0], (list, tuple)) and
+              len(args[0]) == 4):
+            self._pos = args[0][:2]
+            self._size = args[0][2:]
+        elif len(args) == 2:
+            self._pos = tuple(args[0])
+            self._size = tuple(args[1])
+        elif len(args) == 4:
+            self._pos = tuple(args[:2])
+            self._size = tuple(args[2:])
+        elif len(args) != 0:
+            raise TypeError("Rect must be instantiated with 0, 1, 2, or 4 "
+                            "non-keyword arguments.")
+
+        self._pos = kwargs.get('pos', self._pos)
+        self._size = kwargs.get('size', self._size)
+
+        if len(self._pos) != 2 or len(self._size) != 2:
+            raise ValueError("Rect pos and size arguments must have 2 "
+                             "elements.")
+
+    @property
+    def pos(self):
+        return tuple(self._pos)
+
+    @pos.setter
+    def pos(self, p):
+        assert len(p) == 2
+        self._pos = p
+
+    @property
+    def size(self):
+        return tuple(self._size)
+
+    @size.setter
+    def size(self, s):
+        assert len(s) == 2
+        self._size = s
+
+    @property
+    def width(self):
+        return self.size[0]
+
+    @width.setter
+    def width(self, w):
+        self.size = (w, self.size[1])
+
+    @property
+    def height(self):
+        return self.size[1]
+
+    @height.setter
+    def height(self, h):
+        self.size = (self.size[0], h)
+
+    @property
+    def left(self):
+        return self.pos[0]
+
+    @left.setter
+    def left(self, x):
+        self.size = (self.size[0] + (self.pos[0] - x), self.size[1])
+        self.pos = (x, self.pos[1])
+
+    @property
+    def right(self):
+        return self.pos[0] + self.size[0]
+
+    @right.setter
+    def right(self, x):
+        self.size = (x - self.pos[0], self.size[1])
+
+    @property
+    def bottom(self):
+        return self.pos[1]
+
+    @bottom.setter
+    def bottom(self, y):
+        self.size = (self.size[0], self.size[1] + (self.pos[1] - y))
+        self.pos = (self.pos[0], y)
+
+    @property
+    def top(self):
+        return self.pos[1] + self.size[1]
+
+    @top.setter
+    def top(self, y):
+        self.size = (self.size[0], y - self.pos[1])
+
+    @property
+    def center(self):
+        return (self.pos[0] + self.size[0] * 0.5,
+                self.pos[1] + self.size[1] * 0.5)
+
+    @center.setter
+    def center(self, value):
+        delta_x = value[0] - self.center[0]
+        delta_y = value[1] - self.center[1]
+        self.pos = (self.pos[0] + delta_x, self.pos[1] + delta_y)
+
+    def padded(self, padding):
+        """Return a new Rect padded (smaller) by padding on all sides
+
+        Parameters
+        ----------
+        padding : float
+            The padding.
+
+        Returns
+        -------
+        rect : instance of Rect
+            The padded rectangle.
+        """
+        return Rect(pos=(self.pos[0]+padding, self.pos[1]+padding),
+                    size=(self.size[0]-2*padding, self.size[1]-2*padding))
+
+    def normalized(self):
+        """Return a Rect covering the same area, but with height and width
+        guaranteed to be positive.
+        """
+        return Rect(pos=(min(self.left, self.right),
+                         min(self.top, self.bottom)),
+                    size=(abs(self.width), abs(self.height)))
+
+    def flipped(self, x=False, y=True):
+        """Return a Rect with the same bounds but with axes inverted
+
+        Parameters
+        ----------
+        x : bool
+            Flip the X axis.
+        y : bool
+            Flip the Y axis.
+
+        Returns
+        -------
+        rect : instance of Rect
+            The flipped rectangle.
+        """
+        pos = list(self.pos)
+        size = list(self.size)
+        for i, flip in enumerate((x, y)):
+            if flip:
+                pos[i] += size[i]
+                size[i] *= -1
+        return Rect(pos, size)
+
+    def __eq__(self, r):
+        if not isinstance(r, Rect):
+            return False
+        return (np.all(np.equal(r.pos, self.pos)) and
+                np.all(np.equal(r.size, self.size)))
+
+    def __add__(self, a):
+        """Return this Rect translated by *a*."""
+        return self._transform_out(self._transform_in()[:, :2] + a[:2])
+
+    def contains(self, x, y):
+        """Query if the rectangle contains points
+
+        Parameters
+        ----------
+        x : float
+            X coordinate.
+        y : float
+            Y coordinate.
+
+        Returns
+        -------
+        contains : bool
+            True if the point is within the rectangle.
+        """
+        return (x >= self.left and x <= self.right and
+                y >= self.bottom and y <= self.top)
+
+    def __repr__(self):
+        return "<Rect (%g, %g) (%g, %g)>" % (self.pos + self.size)
+
+    def _transform_in(self):
+        """Return array of coordinates that can be mapped by Transform
+        classes.
+        """
+        return np.array([
+            [self.left, self.bottom, 0, 1],
+            [self.right, self.top, 0, 1]])
+
+    def _transform_out(self, coords):
+        """Return a new Rect from coordinates mapped after _transform_in()."""
+        return Rect(pos=coords[0, :2], size=coords[1, :2]-coords[0, :2])

vispy/geometry/tests/test_calculations.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+import numpy as np
+from numpy.testing import assert_allclose
+
+from vispy.testing import assert_raises
+from vispy.geometry import resize
+
+
+def test_resize():
+    """Test image resizing algorithms"""
+    assert_raises(ValueError, resize, np.zeros(3), (3, 3))
+    assert_raises(ValueError, resize, np.zeros((3, 3)), (3,))
+    assert_raises(ValueError, resize, np.zeros((3, 3)), (4, 4), kind='foo')
+    for kind, tol in (('nearest', 1e-5), ('linear', 2e-1)):
+        shape = np.array((10, 11, 3))
+        data = np.random.RandomState(0).rand(*shape)
+        assert_allclose(data, resize(data, shape[:2], kind=kind),
+                        rtol=1e-5, atol=1e-5)
+        # this won't actually be that close for bilinear interp
+        assert_allclose(data, resize(resize(data, 2 * shape[:2], kind=kind),
+                                     shape[:2], kind=kind), atol=tol, rtol=tol)

vispy/geometry/tests/test_generation.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# 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 vispy.testing import run_tests_if_main
+from vispy.geometry import (create_box, create_cube, create_cylinder,
+                            create_sphere, create_plane)
+
+
+def test_box():
+    """Test box function"""
+    vertices, filled, outline = create_box()
+    assert_array_equal(np.arange(len(vertices)), np.unique(filled))
+    assert_array_equal(np.arange(len(vertices)), np.unique(outline))
+
+
+def test_cube():
+    """Test cube function"""
+    vertices, filled, outline = create_cube()
+    assert_array_equal(np.arange(len(vertices)), np.unique(filled))
+    assert_array_equal(np.arange(len(vertices)), np.unique(outline))
+
+
+def test_sphere():
+    """Test sphere function"""
+    md = create_sphere(rows=10, cols=20, radius=10, method='latitude')
+    radii = np.sqrt((md.get_vertices() ** 2).sum(axis=1))
+    assert radii.dtype.type is np.float32
+    assert_allclose(radii, np.ones_like(radii) * 10, atol=1e-06)
+    md = create_sphere(subdivisions=5, radius=10, method='ico')
+    radii = np.sqrt((md.get_vertices() ** 2).sum(axis=1))
+    assert radii.dtype.type is np.float32
+    assert_allclose(radii, np.ones_like(radii) * 10, atol=1e-06)
+    md = create_sphere(rows=20, cols=20, depth=20, radius=10, method='cube')
+    radii = np.sqrt((md.get_vertices() ** 2).sum(axis=1))
+    assert radii.dtype.type is np.float32
+    assert_allclose(radii, np.ones_like(radii) * 10, atol=1e-06)
+
+
+def test_cylinder():
+    """Test cylinder function"""
+    md = create_cylinder(10, 20, radius=[10, 10])
+    radii = np.sqrt((md.get_vertices()[:, :2] ** 2).sum(axis=1))
+    assert_allclose(radii, np.ones_like(radii) * 10)
+
+
+def test_plane():
+    """Test plane function"""
+    vertices, filled, outline = create_plane()
+    assert_array_equal(np.arange(len(vertices)), np.unique(filled))
+    assert_array_equal(np.arange(len(vertices)), np.unique(outline))
+
+
+run_tests_if_main()

vispy/geometry/tests/test_meshdata.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+import numpy as np
+from numpy.testing import assert_array_equal
+
+from vispy.testing import run_tests_if_main
+from vispy.geometry.meshdata import MeshData
+
+
+def test_meshdata():
+    """Test meshdata Class
+    It's a unit square cut in two triangular element
+    """
+    square_vertices = np.array([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]],
+                               dtype=np.float64)
+    square_faces = np.array([[0, 1, 2], [0, 2, 3]], dtype=np.uint8)
+    square_normals = np.array([[0, 0, 1], [0, 0, 1], [0, 0, 1], [0, 0, 1]],
+                              dtype=np.float64)
+    square_edges = np.array([[0, 1], [0, 2], [0, 3], [1, 2], [2, 3]],
+                            dtype=np.uint8)
+
+    mesh = MeshData(vertices=square_vertices, faces=square_faces)
+    # test vertices and faces assignement
+    assert_array_equal(square_vertices, mesh.get_vertices())
+    assert_array_equal(square_faces, mesh.get_faces())
+    # test normals calculus
+    assert_array_equal(square_normals, mesh.get_vertex_normals())
+    # test edge calculus
+    assert_array_equal(square_edges, mesh.get_edges())
+
+
+def test_vertex_normals_indexed_none():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    vertex_normals_unnormalized = np.array(
+        [[-1, -1, -1], [0, -1, -1], [-1, 0, -1], [-1, -1, 0]],
+        dtype=dtype_float)
+    norms = np.sqrt((vertex_normals_unnormalized**2).sum(axis=1,
+                                                         keepdims=True))
+    expected_vertex_normals = vertex_normals_unnormalized / norms
+
+    computed_vertex_normals = mesh.get_vertex_normals(indexed=None)
+
+    assert_array_equal(expected_vertex_normals, computed_vertex_normals)
+
+
+def test_vertex_normals_indexed_faces():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    vertex_normals_unnormalized = np.array(
+        [[-1, -1, -1], [0, -1, -1], [-1, 0, -1], [-1, -1, 0]],
+        dtype=dtype_float)
+    norms = np.sqrt((vertex_normals_unnormalized**2).sum(axis=1,
+                                                         keepdims=True))
+    vertex_normals = vertex_normals_unnormalized / norms
+    expected_vertex_normals = vertex_normals[faces]
+
+    computed_vertex_normals = mesh.get_vertex_normals(indexed="faces")
+
+    assert_array_equal(expected_vertex_normals, computed_vertex_normals)
+
+
+def test_face_normals_indexed_none():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    expected_face_normals = np.array([[0, 0, -1], [-1, 0, 0], [0, -1, 0]],
+                                     dtype=dtype_float)
+
+    computed_face_normals = mesh.get_face_normals(indexed=None)
+
+    assert_array_equal(expected_face_normals, computed_face_normals)
+
+
+def test_face_normals_indexed_faces():
+    dtype_float = np.float32
+    dtype_int = np.int64
+    vertices = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+                        dtype=dtype_float)
+    faces = np.array([[0, 2, 1], [0, 3, 2], [0, 1, 3]], dtype=dtype_int)
+    mesh = MeshData(vertices=vertices, faces=faces)
+    expected_face_normals = np.array([
+        [[0, 0, -1], [0, 0, -1], [0, 0, -1]],
+        [[-1, 0, 0], [-1, 0, 0], [-1, 0, 0]],
+        [[0, -1, 0], [0, -1, 0], [0, -1, 0]]],
+        dtype=dtype_float)
+
+    computed_face_normals = mesh.get_face_normals(indexed="faces")
+
+    assert_array_equal(expected_face_normals, computed_face_normals)
+
+
+run_tests_if_main()