vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/io/image.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+# Author: Luke Campagnola
+# -----------------------------------------------------------------------------
+
+
+import struct
+import zlib
+import numpy as np
+
+
+def _make_png(data, level=6):
+    """Convert numpy array to PNG byte array.
+
+    Parameters
+    ----------
+    data : numpy.ndarray
+        Data must be (H, W, 3 | 4) with dtype = np.ubyte (np.uint8)
+    level : int
+        https://docs.python.org/2/library/zlib.html#zlib.compress
+        An integer from 0 to 9 controlling the level of compression:
+
+            * 1 is fastest and produces the least compression,
+            * 9 is slowest and produces the most.
+            * 0 is no compression.
+
+        The default value is 6.
+
+    Returns
+    -------
+    png : array
+        PNG formatted array
+    """
+    # Eventually we might want to use ext/png.py for this, but this
+    # routine *should* be faster b/c it's specialized for our use case
+
+    def mkchunk(data, name):
+        if isinstance(data, np.ndarray):
+            size = data.nbytes
+        else:
+            size = len(data)
+        chunk = np.empty(size + 12, dtype=np.ubyte)
+        chunk.data[0:4] = np.array(size, '>u4').tobytes()
+        chunk.data[4:8] = name.encode('ASCII')
+        chunk.data[8:8 + size] = data
+        # and-ing may not be necessary, but is done for safety:
+        # https://docs.python.org/3/library/zlib.html#zlib.crc32
+        chunk.data[-4:] = np.array(zlib.crc32(chunk[4:-4]) & 0xffffffff,
+                                   '>u4').tobytes()
+        return chunk
+
+    if data.dtype != np.ubyte:
+        raise TypeError('data.dtype must be np.ubyte (np.uint8)')
+
+    dim = data.shape[2]  # Dimension
+    if dim not in (3, 4):
+        raise TypeError('data.shape[2] must be in (3, 4)')
+
+    # www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.IHDR
+    if dim == 4:
+        ctyp = 0b0110  # RGBA
+    else:
+        ctyp = 0b0010  # RGB
+
+    # www.libpng.org/pub/png/spec/1.2/PNG-Structure.html
+    header = b'\x89PNG\x0d\x0a\x1a\x0a'  # header
+
+    h, w = data.shape[:2]
+    depth = data.itemsize * 8
+    ihdr = struct.pack('!IIBBBBB', w, h, depth, ctyp, 0, 0, 0)
+    c1 = mkchunk(ihdr, 'IHDR')
+
+    # www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.IDAT
+    # insert filter byte at each scanline
+    idat = np.empty((h, w * dim + 1), dtype=np.ubyte)
+    idat[:, 1:] = data.reshape(h, w * dim)
+    idat[:, 0] = 0
+
+    comp_data = zlib.compress(idat, level)
+    c2 = mkchunk(comp_data, 'IDAT')
+    c3 = mkchunk(np.empty((0,), dtype=np.ubyte), 'IEND')
+
+    # concatenate
+    lh = len(header)
+    png = np.empty(lh + c1.nbytes + c2.nbytes + c3.nbytes, dtype=np.ubyte)
+    png.data[:lh] = header
+    p = lh
+
+    for chunk in (c1, c2, c3):
+        png[p:p + len(chunk)] = chunk
+        p += chunk.nbytes
+
+    return png
+
+
+def read_png(filename):
+    """Read a PNG file to RGB8 or RGBA8
+    Requires Pillow.
+
+    Parameters
+    ----------
+    filename : str
+        File to read.
+
+    Returns
+    -------
+    data : array
+        Image data.
+
+    See also
+    --------
+    write_png, imread, imsave
+    """
+    try:
+        from PIL import Image
+        x = Image.open(filename)
+        try:
+            y = np.asarray(x)
+            y = np.array([yy for yy in y], np.uint8)
+        finally:
+            x.close()
+        return y
+    except ImportError:
+        raise RuntimeError("read_png requires the Pillow package.")
+
+
+def write_png(filename, data):
+    """Write a PNG file
+
+    Unlike imsave, this requires no external dependencies.
+
+    Parameters
+    ----------
+    filename : str
+        File to save to.
+    data : array
+        Image data.
+
+    See also
+    --------
+    read_png, imread, imsave
+    """
+    data = np.asarray(data)
+    if not data.ndim == 3 and data.shape[-1] in (3, 4):
+        raise ValueError('data must be a 3D array with last dimension 3 or 4')
+    with open(filename, 'wb') as f:
+        f.write(_make_png(data))  # Save array with make_png
+
+
+def imread(filename, format=None):
+    """Read image data from disk
+
+    Requires imageio or PIL.
+
+    Parameters
+    ----------
+    filename : str
+        Filename to read.
+    format : str | None
+        Format of the file. If None, it will be inferred from the filename.
+
+    Returns
+    -------
+    data : array
+        Image data.
+
+    See also
+    --------
+    imsave, read_png, write_png
+    """
+    imageio, PIL = _check_img_lib()
+    if imageio is not None:
+        return imageio.imread(filename, format)
+    elif PIL is not None:
+        im = PIL.Image.open(filename)
+        if im.mode == 'P':
+            im = im.convert()
+        # Make numpy array
+        a = np.asarray(im)
+        if len(a.shape) == 0:
+            raise MemoryError("Too little memory to convert PIL image to "
+                              "array")
+        return a
+    else:
+        raise RuntimeError("imread requires the imageio or PIL package.")
+
+
+def imsave(filename, im, format=None):
+    """Save image data to disk
+
+    Requires imageio or PIL.
+
+    Parameters
+    ----------
+    filename : str
+        Filename to write.
+    im : array
+        Image data.
+    format : str | None
+        Format of the file. If None, it will be inferred from the filename.
+
+    See also
+    --------
+    imread, read_png, write_png
+    """
+    # Import imageio or PIL
+    imageio, PIL = _check_img_lib()
+    if imageio is not None:
+        return imageio.imsave(filename, im, format)
+    elif PIL is not None:
+        pim = PIL.Image.fromarray(im)
+        pim.save(filename, format)
+    else:
+        raise RuntimeError("imsave requires the imageio or PIL package.")
+
+
+def _check_img_lib():
+    """Utility to search for imageio or PIL"""
+    # Import imageio or PIL
+    imageio = PIL = None
+    try:
+        import imageio
+    except ImportError:
+        try:
+            import PIL.Image
+        except ImportError:
+            pass
+    return imageio, PIL

vispy/io/mesh.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""Reading and writing of data like images and meshes."""
+
+import os
+from os import path as op
+
+from .wavefront import WavefrontReader, WavefrontWriter
+from .stl import load_stl
+
+
+def read_mesh(fname):
+    """Read mesh data from file.
+
+    Parameters
+    ----------
+    fname : str
+        File name to read. Format will be inferred from the filename.
+        Currently only '.obj' and '.obj.gz' are supported.
+
+    Returns
+    -------
+    vertices : array
+        Vertices.
+    faces : array | None
+        Triangle face definitions.
+    normals : array
+        Normals for the mesh.
+    texcoords : array | None
+        Texture coordinates.
+    """
+    # Check format
+    fmt = op.splitext(fname)[1].lower()
+    if fmt == '.gz':
+        fmt = op.splitext(op.splitext(fname)[0])[1].lower()
+
+    if fmt in ('.obj'):
+        return WavefrontReader.read(fname)
+    elif fmt in ('.stl'):
+        file_obj = open(fname, mode='rb')
+        mesh = load_stl(file_obj)
+        vertices = mesh['vertices']
+        faces = mesh['faces']
+        normals = mesh['face_normals']
+        texcoords = None
+        return vertices, faces, normals, texcoords
+    else:
+        try:
+            import meshio
+        except ImportError:
+            raise ValueError('read_mesh does not understand format %s.' % fmt)
+
+        try:
+            mesh = meshio.read(fname)
+        except meshio.ReadError:
+            raise ValueError('read_mesh does not understand format %s.' % fmt)
+
+        triangles = mesh.get_cells_type("triangle")
+        if len(triangles) == 0:
+            raise ValueError('mesh file does not contain triangles.')
+
+        return mesh.points, triangles, None, None
+
+
+def write_mesh(fname, vertices, faces, normals, texcoords, name='',
+               format=None, overwrite=False, reshape_faces=True):
+    """Write mesh data to file.
+
+    Parameters
+    ----------
+    fname : str
+        Filename to write. Must end with ".obj" or ".gz".
+    vertices : array
+        Vertices.
+    faces : array | None
+        Triangle face definitions.
+    normals : array
+        Normals for the mesh.
+    texcoords : array | None
+        Texture coordinates.
+    name : str
+        Name of the object.
+    format : str
+        Currently only "obj" is supported.
+    overwrite : bool
+        If the file exists, overwrite it.
+    reshape_faces : bool
+        Reshape the `faces` array to (Nf, 3). Set to `False`
+        if you need to write a mesh with non triangular faces.
+    """
+    # Check file
+    if op.isfile(fname) and not overwrite:
+        raise IOError('file "%s" exists, use overwrite=True' % fname)
+
+    if format is None:
+        format = os.path.splitext(fname)[1][1:]
+
+    # Check format
+    if format == 'obj':
+        WavefrontWriter.write(fname, vertices, faces,
+                              normals, texcoords, name, reshape_faces)
+        return
+
+    try:
+        import meshio
+    except ImportError:
+        raise ValueError('write_mesh does not understand format %s.' % format)
+
+    cell_data = {}
+    if normals is not None:
+        cell_data["normals"] = [normals]
+    if texcoords is not None:
+        cell_data["texcoords"] = [texcoords]
+
+    mesh = meshio.Mesh(vertices, [("triangle", faces)], cell_data=cell_data)
+
+    try:
+        mesh.write(fname, file_format=format)
+    except meshio.WriteError:
+        raise ValueError('write_mesh does not understand format %s.' % format)

vispy/io/stl.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2015 Michael Dawson-Haggerty
+# Distributed under the MIT License.
+# Copied from the trimesh project.
+# See https://github.com/mikedh/trimesh for more information.
+# See https://github.com/mikedh/trimesh/blob/master/LICENSE.md for
+# the license.
+
+import numpy as np
+
+
+class HeaderError(Exception):
+    # the exception raised if an STL file object doesn't match its header
+    pass
+
+
+# define a numpy datatype for the data section of a binary STL file
+_stl_dtype = np.dtype([('normals', np.float32, (3)),
+                       ('vertices', np.float32, (3, 3)),
+                       ('attributes', np.uint16)])
+# define a numpy datatype for the header of a binary STL file
+_stl_dtype_header = np.dtype([('header', np.void, 80),
+                              ('face_count', np.int32)])
+
+
+def load_stl(file_obj, file_type=None):
+    """
+    Load an STL file from a file object.
+
+    Parameters
+    ----------
+    file_obj: open file- like object
+    file_type: not used
+
+    Returns
+    -------
+    loaded: kwargs for a Trimesh constructor with keys:
+              vertices:     (n,3) float, vertices
+              faces:        (m,3) int, indexes of vertices
+              face_normals: (m,3) float, normal vector of each face
+    """
+    # save start of file obj
+    file_pos = file_obj.tell()
+    try:
+        # check the file for a header which matches the file length
+        # if that is true, it is almost certainly a binary STL file
+        # if the header doesn't match the file length a HeaderError will be
+        # raised
+        return load_stl_binary(file_obj)
+    except HeaderError:
+        # move the file back to where it was initially
+        file_obj.seek(file_pos)
+        # try to load the file as an ASCII STL
+        # if the header doesn't match the file length a HeaderError will be
+        # raised
+        return load_stl_ascii(file_obj)
+
+
+def load_stl_binary(file_obj):
+    """
+    Load a binary STL file from a file object.
+
+    Parameters
+    ----------
+    file_obj: open file- like object
+
+    Returns
+    -------
+    loaded: kwargs for a Trimesh constructor with keys:
+              vertices:     (n,3) float, vertices
+              faces:        (m,3) int, indexes of vertices
+              face_normals: (m,3) float, normal vector of each face
+    """
+    # the header is always 84 bytes long, we just reference the dtype.itemsize
+    # to be explicit about where that magical number comes from
+    header_length = _stl_dtype_header.itemsize
+    header_data = file_obj.read(header_length)
+    if len(header_data) < header_length:
+        raise HeaderError('Binary STL file not long enough to contain header!')
+
+    header = np.fromstring(header_data, dtype=_stl_dtype_header)
+
+    # now we check the length from the header versus the length of the file
+    # data_start should always be position 84, but hard coding that felt ugly
+    data_start = file_obj.tell()
+    # this seeks to the end of the file
+    # position 0, relative to the end of the file 'whence=2'
+    file_obj.seek(0, 2)
+    # we save the location of the end of the file and seek back to where we
+    # started from
+    data_end = file_obj.tell()
+    file_obj.seek(data_start)
+
+    # the binary format has a rigidly defined structure, and if the length
+    # of the file doesn't match the header, the loaded version is almost
+    # certainly going to be garbage.
+    len_data = data_end - data_start
+    len_expected = header['face_count'] * _stl_dtype.itemsize
+
+    # this check is to see if this really is a binary STL file.
+    # if we don't do this and try to load a file that isn't structured properly
+    # we will be producing garbage or crashing hard
+    # so it's much better to raise an exception here.
+    if len_data != len_expected:
+        raise HeaderError('Binary STL has incorrect length in header!')
+
+    # all of our vertices will be loaded in order due to the STL format,
+    # so faces are just sequential indices reshaped.
+    faces = np.arange(header['face_count'] * 3).reshape((-1, 3))
+    blob = np.fromstring(file_obj.read(), dtype=_stl_dtype)
+
+    result = {'vertices': blob['vertices'].reshape((-1, 3)),
+              'face_normals': blob['normals'].reshape((-1, 3)),
+              'faces': faces}
+    return result
+
+
+def load_stl_ascii(file_obj):
+    """
+    Load an ASCII STL file from a file object.
+
+    Parameters
+    ----------
+    file_obj: open file- like object
+
+    Returns
+    -------
+    loaded: kwargs for a Trimesh constructor with keys:
+              vertices:     (n,3) float, vertices
+              faces:        (m,3) int, indexes of vertices
+              face_normals: (m,3) float, normal vector of each face
+    """
+    # header (not used by this function)
+    file_obj.readline()
+
+    text = file_obj.read()
+    if hasattr(text, 'decode'):
+        text = text.decode('utf-8')
+    text = text.lower().split('endsolid')[0]
+    blob = np.array(text.split())
+
+    # there are 21 'words' in each face
+    face_len = 21
+    face_count = len(blob) / face_len
+    if (len(blob) % face_len) != 0:
+        raise HeaderError('Incorrect number of values in STL file!')
+
+    face_count = int(face_count)
+    # this offset is to be added to a fixed set of indices that is tiled
+    offset = face_len * np.arange(face_count).reshape((-1, 1))
+    normal_index = np.tile([2, 3, 4], (face_count, 1)) + offset
+    vertex_index = np.tile(
+        [8, 9, 10, 12, 13, 14, 16, 17, 18], (face_count, 1)) + offset
+
+    # faces are groups of three sequential vertices, as vertices are not
+    # references
+    faces = np.arange(face_count * 3).reshape((-1, 3))
+    face_normals = blob[normal_index].astype(np.float64)
+    vertices = blob[vertex_index.reshape((-1, 3))].astype(np.float64)
+
+    return {'vertices': vertices,
+            'faces': faces,
+            'face_normals': face_normals}
+
+
+_stl_loaders = {'stl': load_stl,
+                'stl_ascii': load_stl}

vispy/io/tests/test_image.py

@@ -0,0 +1,47 @@
+# -*- 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 os import path as op
+import warnings
+
+from vispy.io import load_crate, imsave, imread, read_png, write_png
+from vispy.testing import requires_img_lib, run_tests_if_main
+from vispy.util import _TempDir
+
+temp_dir = _TempDir()
+
+
+def test_make_png():
+    """Test to ensure that make_png functions correctly."""
+    # Save random RGBA and RGB arrays onto disk as PNGs using make_png.
+    # Read them back with an image library and check whether the array
+    # saved is equal to the array read.
+
+    # Create random RGBA array as type ubyte
+    rgba_save = np.random.randint(256, size=(100, 100, 4)).astype(np.ubyte)
+    # Get rid of the alpha for RGB
+    rgb_save = rgba_save[:, :, :3]
+    # Output file should be in temp
+    png_out = op.join(temp_dir, 'random.png')
+
+    # write_png implicitly tests _make_png
+    for rgb_a in (rgba_save, rgb_save):
+        write_png(png_out, rgb_a)
+        rgb_a_read = read_png(png_out)
+        assert_array_equal(rgb_a, rgb_a_read)
+
+
+@requires_img_lib()
+def test_read_write_image():
+    """Test reading and writing of images"""
+    fname = op.join(temp_dir, 'out.png')
+    im1 = load_crate()
+    imsave(fname, im1, format='png')
+    with warnings.catch_warnings(record=True):  # PIL unclosed file
+        im2 = imread(fname)
+    assert_allclose(im1, im2)
+
+
+run_tests_if_main()

vispy/io/tests/test_io.py

@@ -0,0 +1,121 @@
+# -*- 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 os import path as op
+from numpy.testing import assert_allclose, assert_array_equal
+
+from vispy.io import write_mesh, read_mesh, load_data_file
+from vispy.geometry import _fast_cross_3d
+from vispy.util import _TempDir
+from vispy.testing import (run_tests_if_main, assert_equal, assert_raises,
+                           requires_ssl)
+
+temp_dir = _TempDir()
+
+
+@requires_ssl()
+def test_wavefront():
+    """Test wavefront reader"""
+    fname_mesh = load_data_file('orig/triceratops.obj.gz')
+    fname_out = op.join(temp_dir, 'temp.obj')
+    mesh1 = read_mesh(fname_mesh)
+    assert_raises(IOError, read_mesh, 'foo.obj')
+    assert_raises(ValueError, read_mesh, op.abspath(__file__))
+    assert_raises(ValueError, write_mesh, fname_out, *mesh1, format='foo')
+    write_mesh(fname_out, mesh1[0], mesh1[1], mesh1[2], mesh1[3])
+    assert_raises(IOError, write_mesh, fname_out, *mesh1)
+    write_mesh(fname_out, *mesh1, overwrite=True)
+    mesh2 = read_mesh(fname_out)
+    assert_equal(len(mesh1), len(mesh2))
+    for m1, m2 in zip(mesh1, mesh2):
+        if m1 is None:
+            assert_equal(m2, None)
+        else:
+            assert_allclose(m1, m2, rtol=1e-5)
+    # test our efficient normal calculation routine
+    assert_allclose(mesh1[2], _slow_calculate_normals(mesh1[0], mesh1[1]),
+                    rtol=1e-7, atol=1e-7)
+
+
+def test_wavefront_non_triangular():
+    """Test wavefront writing with non-triangular faces"""
+    vertices = np.array([[0.5, 1.375, 0.],
+                         [0.5, 0.625, 0.],
+                         [3.25, 1., 0.],
+                         [1., 0.375, 0.],
+                         [2., 0.375, 0.],
+                         [1.5, 0.625, 0.],
+                         [1.5, 1.375, 0.],
+                         [1., 1.625, 0.],
+                         [2., 1.625, 0.]])
+
+    faces = np.array([[1, 0, 7, 6, 5, 3],
+                      [4, 5, 6, 8, 2]], dtype=object)
+    fname_out = op.join(temp_dir, 'temp.obj')
+    write_mesh(fname_out, vertices=vertices,
+               faces=faces, normals=None,
+               texcoords=None, overwrite=True,
+               reshape_faces=False)
+    assert_raises(RuntimeError, read_mesh, fname_out)
+    with open(fname_out, 'r+') as out_file:
+        lines = out_file.readlines()
+    assert lines[-1].startswith('f 5 6 7 9 3')
+    assert lines[-2].startswith('f 2 1 8 7 6 4')
+
+
+def test_meshio():
+    """Test meshio i/o"""
+    vertices = np.array([[0.0, 0.0, 0.0],
+                         [1.0, 0.0, 0.],
+                         [-.0, 1.0, 0.],
+                         [1.0, 1.0, 0.]])
+
+    faces = np.array([[0, 1, 3],
+                      [1, 2, 3]])
+    fname_out = op.join(temp_dir, 'temp.vtk')
+    write_mesh(fname_out, vertices=vertices,
+               faces=faces, normals=None,
+               texcoords=None, overwrite=True,
+               reshape_faces=False)
+    out_vertices, out_faces, _, _ = read_mesh(fname_out)
+
+    assert np.all(np.abs(out_vertices - vertices) < 1.0e-14)
+    assert np.all(out_faces == faces)
+
+
+def _slow_calculate_normals(rr, tris):
+    """Efficiently compute vertex normals for triangulated surface"""
+    # first, compute triangle normals
+    rr = rr.astype(np.float64)
+    r1 = rr[tris[:, 0], :]
+    r2 = rr[tris[:, 1], :]
+    r3 = rr[tris[:, 2], :]
+    tri_nn = np.cross((r2 - r1), (r3 - r1))
+
+    #   Triangle normals and areas
+    size = np.sqrt(np.sum(tri_nn * tri_nn, axis=1))
+    zidx = np.where(size == 0)[0]
+    size[zidx] = 1.0  # prevent ugly divide-by-zero
+    tri_nn /= size[:, np.newaxis]
+
+    # accumulate the normals
+    nn = np.zeros((len(rr), 3))
+    for p, verts in enumerate(tris):
+        nn[verts] += tri_nn[p, :]
+    size = np.sqrt(np.sum(nn * nn, axis=1))
+    size[size == 0] = 1.0  # prevent ugly divide-by-zero
+    nn /= size[:, np.newaxis]
+    return nn
+
+
+def test_huge_cross():
+    """Test cross product with lots of elements"""
+    x = np.random.rand(100000, 3)
+    y = np.random.rand(1, 3)
+    z = np.cross(x, y)
+    zz = _fast_cross_3d(x, y)
+    assert_array_equal(z, zz)
+
+
+run_tests_if_main()