vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/ext/gdi32plus.py

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+# Adapted from Pyglet
+
+import atexit
+from functools import partial
+import struct
+
+from ctypes import (windll, Structure, POINTER, byref, WINFUNCTYPE,
+                    c_uint, c_float, c_int, c_ulong, c_uint64,
+                    c_void_p, c_uint32, c_wchar, c_wchar_p)
+from ctypes.wintypes import (LONG, BYTE, HFONT, HGDIOBJ, BOOL, UINT, INT,
+                             DWORD, LPARAM)
+
+try:
+    import _winreg as winreg
+except ImportError:
+    import winreg  # noqa, analysis:ignore
+
+_64_bit = (8 * struct.calcsize("P")) == 64
+
+LF_FACESIZE = 32
+FW_BOLD = 700
+FW_NORMAL = 400
+ANTIALIASED_QUALITY = 4
+FontStyleBold = 1
+FontStyleItalic = 2
+UnitPixel = 2
+UnitPoint = 3
+DEFAULT_CHARSET = 1
+ANSI_CHARSET = 0
+TRUETYPE_FONTTYPE = 4
+GM_ADVANCED = 2
+CSIDL_FONTS = 0x0014
+
+PixelFormat24bppRGB = 137224
+PixelFormat32bppRGB = 139273
+PixelFormat32bppARGB = 2498570
+
+DriverStringOptionsCmapLookup = 1
+DriverStringOptionsRealizedAdvance = 4
+TextRenderingHintAntiAlias = 4
+TextRenderingHintAntiAliasGridFit = 3
+ImageLockModeRead = 1
+StringFormatFlagsMeasureTrailingSpaces = 0x00000800
+StringFormatFlagsNoClip = 0x00004000
+StringFormatFlagsNoFitBlackBox = 0x00000004
+
+INT_PTR = c_int
+REAL = c_float
+TCHAR = c_wchar
+UINT32 = c_uint32
+HDC = c_void_p
+PSTR = c_uint64 if _64_bit else c_uint
+
+HORZSIZE = 4
+VERTSIZE = 6
+
+HORZRES = 8
+VERTRES = 10
+
+
+# gdi32
+
+class POINT(Structure):
+    _fields_ = [('x', LONG), ('y', LONG)]
+
+
+class RECT(Structure):
+    _fields_ = [('left', LONG), ('top', LONG),
+                ('right', LONG), ('bottom', LONG)]
+
+
+class PANOSE(Structure):
+    _fields_ = [
+        ('bFamilyType', BYTE), ('bSerifStyle', BYTE), ('bWeight', BYTE),
+        ('bProportion', BYTE), ('bContrast', BYTE), ('bStrokeVariation', BYTE),
+        ('bArmStyle', BYTE), ('bLetterform', BYTE), ('bMidline', BYTE),
+        ('bXHeight', BYTE)]
+
+
+class TEXTMETRIC(Structure):
+    _fields_ = [
+        ('tmHeight', LONG), ('tmAscent', LONG), ('tmDescent', LONG),
+        ('tmInternalLeading', LONG), ('tmExternalLeading', LONG),
+        ('tmAveCharWidth', LONG), ('tmMaxCharWidth', LONG),
+        ('tmWeight', LONG), ('tmOverhang', LONG),
+        ('tmDigitizedAspectX', LONG), ('tmDigitizedAspectY', LONG),
+        ('tmFirstChar', TCHAR), ('tmLastChar', TCHAR),
+        ('tmDefaultChar', TCHAR), ('tmBreakChar', TCHAR),
+        ('tmItalic', BYTE), ('tmUnderlined', BYTE),
+        ('tmStruckOut', BYTE), ('tmPitchAndFamily', BYTE),
+        ('tmCharSet', BYTE)]
+
+
+class OUTLINETEXTMETRIC(Structure):
+    _fields_ = [
+        ('otmSize', UINT), ('otmTextMetrics', TEXTMETRIC),
+        ('otmMysteryBytes', BYTE), ('otmPanoseNumber', PANOSE),
+        ('otmMysteryByte', BYTE),
+        ('otmfsSelection', UINT), ('otmfsType', UINT),
+        ('otmsCharSlopeRise', INT), ('otmsCharSlopeRun', INT),
+        ('otmItalicAngle', INT), ('otmEMSquare', UINT), ('otmAscent', INT),
+        ('otmDescent', INT), ('otmLineGap', UINT), ('otmsCapEmHeight', UINT),
+        ('otmsXHeight', UINT), ('otmrcFontBox', RECT), ('otmMacAscent', INT),
+        ('otmMacDescent', INT), ('otmMacLineGap', UINT),
+        ('otmusMinimumPPEM', UINT), ('otmptSubscriptSize', POINT),
+        ('otmptSubscriptOffset', POINT), ('otmptSuperscriptSize', POINT),
+        ('otmptSuperscriptOffset', POINT), ('otmsStrikeoutSize', UINT),
+        ('otmsStrikeoutPosition', INT), ('otmsUnderscoreSize', INT),
+        ('otmsUnderscorePosition', INT), ('otmpFamilyName', PSTR),
+        ('otmpFaceName', PSTR), ('otmpStyleName', PSTR),
+        ('otmpFullName', PSTR), ('junk', (BYTE) * 1024)]  # room for strs
+
+
+class LOGFONT(Structure):
+    _fields_ = [
+        ('lfHeight', LONG), ('lfWidth', LONG), ('lfEscapement', LONG),
+        ('lfOrientation', LONG), ('lfWeight', LONG), ('lfItalic', BYTE),
+        ('lfUnderline', BYTE), ('lfStrikeOut', BYTE), ('lfCharSet', BYTE),
+        ('lfOutPrecision', BYTE), ('lfClipPrecision', BYTE),
+        ('lfQuality', BYTE), ('lfPitchAndFamily', BYTE),
+        ('lfFaceName', (TCHAR * LF_FACESIZE))]
+
+
+gdi32 = windll.gdi32
+
+gdi32.CreateFontIndirectW.restype = HFONT
+gdi32.CreateFontIndirectW.argtypes = [POINTER(LOGFONT)]
+
+gdi32.SelectObject.restype = HGDIOBJ
+gdi32.SelectObject.argtypes = [HDC, HGDIOBJ]
+
+gdi32.SetGraphicsMode.restype = INT
+gdi32.SetGraphicsMode.argtypes = [HDC, INT]
+
+gdi32.GetTextMetricsW.restype = BOOL
+gdi32.GetTextMetricsW.argtypes = [HDC, POINTER(TEXTMETRIC)]
+
+FONTENUMPROC = WINFUNCTYPE(INT, POINTER(LOGFONT), POINTER(TEXTMETRIC),
+                           DWORD, c_void_p)
+gdi32.EnumFontFamiliesExW.restype = INT
+gdi32.EnumFontFamiliesExW.argtypes = [HDC, POINTER(LOGFONT),
+                                      FONTENUMPROC, LPARAM, DWORD]
+
+gdi32.GetOutlineTextMetricsW.restype = UINT
+gdi32.GetOutlineTextMetricsW.argtypes = [HDC, UINT,
+                                         POINTER(OUTLINETEXTMETRIC)]
+
+
+gdi32.GetDeviceCaps.argtypes = [HDC, INT]
+gdi32.GetDeviceCaps.restype = INT
+
+user32 = windll.user32
+
+user32.GetDC.restype = HDC  # HDC
+user32.GetDC.argtypes = [UINT32]  # HWND
+
+user32.ReleaseDC.argtypes = [c_void_p, HDC]
+
+try:
+    user32.SetProcessDPIAware.argtypes = []
+except AttributeError:
+    pass  # not present on XP
+
+
+# gdiplus
+
+class GdiplusStartupInput(Structure):
+    _fields_ = [
+        ('GdiplusVersion', UINT32), ('DebugEventCallback', c_void_p),
+        ('SuppressBackgroundThread', BOOL), ('SuppressExternalCodecs', BOOL)]
+
+
+class GdiplusStartupOutput(Structure):
+    _fields = [('NotificationHookProc', c_void_p),
+               ('NotificationUnhookProc', c_void_p)]
+
+gdiplus = windll.gdiplus
+
+gdiplus.GdipCreateFontFamilyFromName.restype = c_int
+gdiplus.GdipCreateFontFamilyFromName.argtypes = [c_wchar_p, c_void_p, c_void_p]
+
+gdiplus.GdipNewPrivateFontCollection.restype = c_int
+gdiplus.GdipNewPrivateFontCollection.argtypes = [c_void_p]
+
+gdiplus.GdipPrivateAddFontFile.restype = c_int
+gdiplus.GdipPrivateAddFontFile.argtypes = [c_void_p, c_wchar_p]
+
+gdiplus.GdipGetFamilyName.restype = c_int
+gdiplus.GdipGetFamilyName.argtypes = [c_void_p, c_wchar_p, c_int]
+
+
+def gdiplus_init():
+    token = c_ulong()
+    startup_in = GdiplusStartupInput()
+    startup_in.GdiplusVersion = 1
+    startup_out = GdiplusStartupOutput()
+    gdiplus.GdiplusStartup(byref(token), byref(startup_in), byref(startup_out))
+    atexit.register(partial(gdiplus.GdiplusShutdown, token))
+
+gdiplus_init()

vispy/ext/osmesa.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+# vispy: testskip
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""A ctypes-based API to OSMesa"""
+from __future__ import print_function
+import os
+import ctypes
+import ctypes.util
+from ctypes import c_int as _c_int, c_uint as _c_uint, c_void_p
+
+# See vispy/gloo/gl/_constants.py for reference
+GL_RGBA = 6408
+GL_UNSIGNED_BYTE = 5121
+GL_VERSION = 7938
+
+_osmesa_file = None
+if 'OSMESA_LIBRARY' in os.environ:
+    if os.path.exists(os.environ['OSMESA_LIBRARY']):
+        _osmesa_file = os.path.realpath(os.environ['OSMESA_LIBRARY'])
+
+# Else, try to find it
+if _osmesa_file is None:
+    _osmesa_file = ctypes.util.find_library('OSMesa')
+
+# Else, we failed and exit
+if _osmesa_file is None:
+    raise OSError('OSMesa library not found')
+
+# Load it
+_lib = ctypes.CDLL(_osmesa_file)
+
+# Constants
+OSMESA_RGBA = GL_RGBA
+
+# Functions
+
+# GLAPI OSMesaContext GLAPIENTRY
+# OSMesaCreateContext( GLenum format, OSMesaContext sharelist );
+_lib.OSMesaCreateContext.argtypes = _c_int, c_void_p
+_lib.OSMesaCreateContext.restype = c_void_p
+# GLAPI void GLAPIENTRY
+# OSMesaDestroyContext( OSMesaContext ctx );
+_lib.OSMesaDestroyContext.argtypes = c_void_p,
+# GLAPI GLboolean GLAPIENTRY
+# OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type,
+#                   GLsizei width, GLsizei height );
+_lib.OSMesaMakeCurrent.argtypes = c_void_p, c_void_p, _c_int, _c_int, _c_int
+_lib.OSMesaMakeCurrent.restype = _c_int
+# GLAPI OSMesaContext GLAPIENTRY
+# OSMesaGetCurrentContext( void );
+_lib.OSMesaGetCurrentContext.restype = c_void_p
+
+
+def allocate_pixels_buffer(width, height):
+    """Helper function to allocate a buffer to contain an image of
+    width * height suitable for OSMesaMakeCurrent
+    """
+    # Seems like OSMesa has some trouble with non-RGBA buffers, so enforce
+    # RGBA
+    return (_c_uint * width * height * 4)()
+
+
+def OSMesaCreateContext():
+    return ctypes.cast(_lib.OSMesaCreateContext(OSMESA_RGBA, None), c_void_p)
+
+
+def OSMesaDestroyContext(context):
+    _lib.OSMesaDestroyContext(context)
+
+
+def OSMesaMakeCurrent(context, buffer, width, height):
+    ret = _lib.OSMesaMakeCurrent(context, buffer, GL_UNSIGNED_BYTE,
+                                 width, height)
+    return ret != 0
+
+
+def OSMesaGetCurrentContext():
+    return c_void_p(_lib.OSMesaGetCurrentContext())
+
+if __name__ == '__main__':
+    """This test basic OSMesa functionality"""
+    # If you have OSMesa installed alongside normal OpenGL, execute with
+    # VISPY_GL_LIB=/opt/osmesa_llvmpipe/lib/libGLESv2.so \
+    #   LD_LIBRARY_PATH=/opt/osmesa_llvmpipe/lib/ \
+    #   OSMESA_LIBRARY=/opt/osmesa_llvmpipe/lib/libOSMesa.so \
+    #   python vispy/ext/osmesa.py
+    context = OSMesaCreateContext()
+    w, h = 640, 480
+    pixels = allocate_pixels_buffer(w, h)
+    ok = OSMesaMakeCurrent(context, pixels, 640, 480)
+    if not ok:
+        raise RuntimeError('Failed OSMesaMakeCurrent')
+    if not (OSMesaGetCurrentContext().value == context.value):
+        raise RuntimeError('OSMesa context not correctly attached')
+
+    _lib.glGetString.argtypes = (ctypes.c_uint,)
+    _lib.glGetString.restype = ctypes.c_char_p
+
+    print("OpenGL version : ", _lib.glGetString(GL_VERSION))
+
+    OSMesaDestroyContext(context)
+    if OSMesaGetCurrentContext().value is not None:
+        raise RuntimeError('Failed to destroy OSMesa context')

vispy/geometry/__init__.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.
+
+"""This module implements classes and methods for handling geometric data."""
+
+from __future__ import division
+
+__all__ = ['MeshData', 'PolygonData', 'Rect', 'Triangulation', 'triangulate',
+           'create_arrow', 'create_box', 'create_cone', 'create_cube',
+           'create_cylinder', 'create_grid_mesh', 'create_plane',
+           'create_sphere', 'resize']
+
+from .polygon import PolygonData  # noqa
+from .meshdata import MeshData  # noqa
+from .rect import Rect  # noqa
+from .triangulation import Triangulation, triangulate  # noqa
+from .torusknot import TorusKnot  # noqa
+from .calculations import (_calculate_normals, _fast_cross_3d,  # noqa
+                           resize)  # noqa
+from .generation import (create_arrow, create_box, create_cone,  # noqa
+                         create_cube, create_cylinder, create_grid_mesh,  # noqa
+                         create_plane, create_sphere)  # noqa

vispy/geometry/_triangulation_debugger.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""
+Debugging system for Triangulation class. Displays stepwise visual 
+representation of the algorithm. 
+
+This system currently requires pyqtgraph for its visual output.
+"""
+from __future__ import division
+
+import numpy as np
+import time
+
+from ..util.geometry.triangulation import Triangulation
+
+
+class DebugTriangulation(Triangulation):
+    """Visualize triangulation process stepwise to aid in debugging.
+
+    *interval* specifies the diration to wait before drawing each update in
+    the triangulation procedure. Negative values cause the display to wait
+    until the user clicks on the window for each update.
+
+    *skip* causes the display to immediately process the first N events
+    before pausing.
+    """
+
+    def __init__(self, pts, edges, interval=0.01, skip=0):
+        self.interval = interval
+        self.iteration = 0
+        self.skip = skip 
+
+        Triangulation.__init__(self, pts, edges)
+
+        # visual #debugging: draw edges, front, triangles
+        self.win = pg.plot()
+        self.graph = pg.GraphItem(pos=pts.copy(), adj=edges.copy(), 
+                                  pen={'width': 3, 'color': (0, 100, 0)})
+        self.win.addItem(self.graph)
+        self.front_line = pg.PlotCurveItem(pen={'width': 2, 
+                                                'dash': [5, 5], 
+                                                'color': 'y'})
+        self.win.addItem(self.front_line)
+        self.tri_shapes = {}
+
+        self.nextStep = False
+        self.win.scene().sigMouseClicked.connect(self.mouseClicked)
+
+    def mouseClicked(self):
+        self.nextStep = True
+
+    def draw_state(self):
+        global app
+        print("State %s" % self.iteration)
+        self.iteration += 1
+        if self.iteration <= self.skip:
+            return
+
+        front_pts = self.pts[np.array(self.front)]
+        self.front_line.setData(front_pts[:, 0], front_pts[:, 1])
+        self.graph.setData(pos=self.pts, adj=self.edges) 
+
+        # Auto-advance on timer
+        if self.interval < 0:
+            # Advance once per click
+            while True:
+                app.processEvents()
+                time.sleep(0.01)
+                if self.nextStep:
+                    self.nextStep = False
+                    break
+        else:
+            # sleep, but keep ui responsive
+            for i in range(int(self.interval / 0.01)):
+                app.processEvents()
+                time.sleep(0.01)
+
+    def draw_tri(self, tri, source=None):
+        # assign triangle color based on the source that generated it
+        color = {
+            None: (0, 255, 255, 50),
+            'smooth1': (0, 255, 0, 50),
+            'fill_hull': (255, 255, 0, 50),
+            'edge_event': (100, 100, 255, 100),
+        }[source]
+
+        tpts = self.pts[np.array(tri)]
+        path = pg.arrayToQPath(tpts[:, 0], tpts[:, 1])
+        shape = pg.QtGui.QGraphicsPathItem(path)
+        shape.setPen(pg.mkPen(255, 255, 255, 100))
+        brush = pg.mkBrush(color)
+        shape.setBrush(brush)
+        self.win.addItem(shape)
+        self.tri_shapes[tri] = shape
+        self.draw_state()
+
+    def undraw_tri(self, tri):
+        shape = self.tri_shapes.pop(tri)
+        self.win.removeItem(shape)
+        self.draw_state()
+
+    def add_tri(self, *args, **kwargs):
+        Triangulation._add_tri(self, *args, **kwargs)
+        self.draw_tri(list(self.tris.keys())[-1], 
+                      source=kwargs.get('source', None))
+
+    def remove_tri(self, *args, **kwargs):
+        k = Triangulation._remove_tri(self, *args, **kwargs)
+        self.undraw_tri(k)
+
+    def edge_event(self, *args, **kwargs):
+        self.draw_state()
+        Triangulation._edge_event(self, *args, **kwargs)
+        self.draw_state()
+
+
+if __name__ == '__main__':
+    import pyqtgraph as pg
+
+    app = pg.mkQApp()
+
+    # user input data - points and constraining edges
+
+    #
+    #  Test 1
+    #
+    pts = [(0, 0),
+           (10, 0),
+           (10, 10),
+           (20, 10),
+           (20, 20),
+           (25, 20),
+           (25, 25),
+           (20, 25),
+           (20, 20),
+           (10, 17),
+           (5, 25),
+           (9, 30),
+           (6, 15),
+           (15, 12.5),
+           (0, 5)]
+    num_pts = len(pts)
+    edges = [(i, (i+1) % num_pts) for i in range(num_pts)]
+    pts += [(21, 21),
+            (24, 21),
+            (24, 24),
+            (21, 24)]
+    edges += [(num_pts, num_pts + 1),
+              (num_pts + 1, num_pts + 2),
+              (num_pts + 2, num_pts + 3),
+              (num_pts + 3, num_pts)]
+
+    pts = np.array(pts, dtype=float)
+    edges = np.array(edges, dtype=int)
+
+    # t = DebugTriangulation(pts, edges, interval=-1, skip=19570)
+    # t.triangulate()
+
+    # 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 = DebugTriangulation(pts, edges)
+    t.triangulate()

vispy/geometry/calculations.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""Miscellaneous functions"""
+
+import numpy as np
+
+
+###############################################################################
+# These fast normal calculation routines are adapted from mne-python
+
+def _fast_cross_3d(x, y):
+    """Compute cross product between list of 3D vectors
+
+    Much faster than np.cross() when the number of cross products
+    becomes large (>500). This is because np.cross() methods become
+    less memory efficient at this stage.
+
+    Parameters
+    ----------
+    x : array
+        Input array 1.
+    y : array
+        Input array 2.
+
+    Returns
+    -------
+    z : array
+        Cross product of x and y.
+
+    Notes
+    -----
+    x and y must both be 2D row vectors. One must have length 1, or both
+    lengths must match.
+    """
+    assert x.ndim == 2
+    assert y.ndim == 2
+    assert x.shape[1] == 3
+    assert y.shape[1] == 3
+    assert (x.shape[0] == 1 or y.shape[0] == 1) or x.shape[0] == y.shape[0]
+    if max([x.shape[0], y.shape[0]]) >= 500:
+        return np.c_[x[:, 1] * y[:, 2] - x[:, 2] * y[:, 1],
+                     x[:, 2] * y[:, 0] - x[:, 0] * y[:, 2],
+                     x[:, 0] * y[:, 1] - x[:, 1] * y[:, 0]]
+    else:
+        return np.cross(x, y)
+
+
+def _calculate_normals(rr, tris):
+    """Efficiently compute vertex normals for triangulated surface"""
+    # ensure highest precision for our summation/vectorization "trick"
+    rr = rr.astype(np.float64)
+    # first, compute triangle normals
+    r1 = rr[tris[:, 0], :]
+    r2 = rr[tris[:, 1], :]
+    r3 = rr[tris[:, 2], :]
+    tri_nn = _fast_cross_3d((r2 - r1), (r3 - r1))
+
+    #   Triangle normals and areas
+    size = np.sqrt(np.sum(tri_nn * tri_nn, axis=1))
+    size[size == 0] = 1.0  # prevent ugly divide-by-zero
+    tri_nn /= size[:, np.newaxis]
+
+    npts = len(rr)
+
+    # the following code replaces this, but is faster (vectorized):
+    #
+    # for p, verts in enumerate(tris):
+    #     nn[verts, :] += tri_nn[p, :]
+    #
+    nn = np.zeros((npts, 3))
+    for verts in tris.T:  # note this only loops 3x (number of verts per tri)
+        for idx in range(3):  # x, y, z
+            nn[:, idx] += np.bincount(verts.astype(np.int32),
+                                      tri_nn[:, idx], minlength=npts)
+    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 resize(image, shape, kind='linear'):
+    """Resize an image
+
+    Parameters
+    ----------
+    image : ndarray
+        Array of shape (N, M, ...).
+    shape : tuple
+        2-element shape.
+    kind : str
+        Interpolation, either "linear" or "nearest".
+
+    Returns
+    -------
+    scaled_image : ndarray
+        New image, will have dtype np.float64.
+    """
+    image = np.array(image, float)
+    shape = np.array(shape, int)
+    if shape.ndim != 1 or shape.size != 2:
+        raise ValueError('shape must have two elements')
+    if image.ndim < 2:
+        raise ValueError('image must have two dimensions')
+    if not isinstance(kind, str) or kind not in ('nearest', 'linear'):
+        raise ValueError('mode must be "nearest" or "linear"')
+
+    r = np.linspace(0, image.shape[0] - 1, shape[0])
+    c = np.linspace(0, image.shape[1] - 1, shape[1])
+    if kind == 'linear':
+        r_0 = np.floor(r).astype(int)
+        c_0 = np.floor(c).astype(int)
+        r_1 = r_0 + 1
+        c_1 = c_0 + 1
+
+        top = (r_1 - r)[:, np.newaxis]
+        bot = (r - r_0)[:, np.newaxis]
+        lef = (c - c_0)[np.newaxis, :]
+        rig = (c_1 - c)[np.newaxis, :]
+
+        c_1 = np.minimum(c_1, image.shape[1] - 1)
+        r_1 = np.minimum(r_1, image.shape[0] - 1)
+        for arr in (top, bot, lef, rig):
+            arr.shape = arr.shape + (1,) * (image.ndim - 2)
+        out = top * rig * image[r_0][:, c_0, ...]
+        out += bot * rig * image[r_1][:, c_0, ...]
+        out += top * lef * image[r_0][:, c_1, ...]
+        out += bot * lef * image[r_1][:, c_1, ...]
+    else:  # kind == 'nearest'
+        r = np.round(r).astype(int)
+        c = np.round(c).astype(int)
+        out = image[r][:, c, ...]
+    return out