alignfaces 1.0.1__py3-none-any.whl

alignfaces/tests/test_warp_tools.py

@@ -0,0 +1,316 @@
+import numpy as np
+from alignfaces.warp_tools import bilin
+from alignfaces.warp_tools import pawarp
+from numpy.fft  import fft2, ifft2
+
+#################################################################
+#  HELPER FUNCTIONS
+#################################################################
+def _make_pixarr(limits):
+    xmn, ymn = limits[0], limits[0]
+    xmx, ymx = limits[1], limits[1]
+    x = np.arange(xmn, xmx + 1)
+    y = np.arange(ymn, ymx + 1)
+    xx, yy = np.meshgrid(x, y)
+    pixarr = (xx.flatten(), yy.flatten())
+    pixarr = np.transpose(np.array(pixarr))
+    return pixarr
+
+
+def _random_locations(im_size, num_loc=4, min_dist=5):
+    """create array of num_loc points within min distance of min_dist pixels"""
+    PAD = int(im_size * .15)
+    locations =     (np.random.rand(1, 2) * (im_size-1-PAD*2)+PAD).astype(int)
+    total = 1
+    while total < num_loc:
+        # Sample new point.
+        loc =       (np.random.rand(1, 2) * (im_size-1-PAD*2)+PAD).astype(int)
+
+        SAMPLE_NEW = 0;
+        for SETLOC in locations:
+            if np.sqrt(((SETLOC-loc)**2).sum()) <= min_dist:
+                # Bad sample. Skip to beginning of loop for new sample.
+                SAMPLE_NEW = 1;
+        if SAMPLE_NEW:
+            continue
+
+        # Good sample. Append to results.
+        locations = np.r_[locations, loc]
+        total += 1
+    IND = _locations_to_indices(im_size, locations)
+    locations = _indices_to_locations(im_size, IND)
+    return locations, IND
+
+
+def _perturb_locations(locations, max_value, change_range):
+    num_targets = locations.shape[0]
+    noise = np.random.rand(num_targets, 2)
+    other_locations = ((noise-.5) * change_range + locations).astype(int)
+    other_locations[other_locations < 0] = 0
+    other_locations[other_locations > max_value] = max_value
+    return other_locations
+
+
+def _image_with_donut_targets(im_size=64, locations=((8, 8),(32, 32))):
+    """make zero image with targets at locations. also return target"""
+    # Target
+    B = np.zeros((3, 3))
+
+    B[1, 1] = 9 * 8
+    B[0, 1] = -9
+    B[2, 1] = -9
+    B[1, 0] = -9
+    B[1, 2] = -9
+
+    B[0, 0] = -9
+    B[0, 2] = -9
+    B[2, 0] = -9
+    B[2, 2] = -9
+
+    # Image with targets
+    A = np.zeros((im_size, im_size))
+    for l in locations:
+        tr, tc = l
+        A[1 + tr - 1, 1 + tc - 1] = B[1, 1]
+        A[0 + tr - 1, 1 + tc - 1] = B[0, 1]
+        A[2 + tr - 1, 1 + tc - 1] = B[2, 1]
+        A[1 + tr - 1, 0 + tc - 1] = B[1, 0]
+        A[1 + tr - 1, 2 + tc - 1] = B[1, 2]
+
+        A[0 + tr - 1, 0 + tc - 1] = B[0, 0]
+        A[0 + tr - 1, 2 + tc - 1] = B[0, 2]
+        A[2 + tr - 1, 0 + tc - 1] = B[2, 0]
+        A[2 + tr - 1, 2 + tc - 1] = B[2, 2]
+
+    img, target = A, B
+    return img, target
+
+
+def _fft_convolve2d(x, y):
+    """ 2D convolution, using FFT"""
+    pad = np.array(x.shape) - np.array(y.shape)
+    if pad[0] % 2 == 0:
+        rb, ra = int(pad[0]/2)+1, int(pad[0]/2)-1
+    else:
+        rb, ra = int(np.ceil(pad[0]/2)), int(np.floor(pad[0]/2))
+    if pad[1] % 2 == 0:
+        cb, ca = int(pad[1]/2)+1, int(pad[1]/2)-1
+    else:
+        cb, ca = int(np.ceil(pad[1]/2)), int(np.floor(pad[1]/2))
+    pad_width = ((rb, ra), (cb, ca))
+    py = np.pad(y, pad_width, mode="constant")
+
+    fr = fft2(x)
+    fr2 = fft2(np.flipud(np.fliplr(py)))
+    m,n = fr.shape
+    cc = np.real(ifft2(fr*fr2))
+    cc = np.roll(cc, int(-m/2+1), axis=0)
+    cc = np.roll(cc, int(-n/2+1), axis=1)
+    return cc
+
+
+def _locations_to_indices(img_width, locations):
+    num_targets = locations.shape[0]
+    IND = np.zeros(num_targets, )
+    for i, rc in enumerate(locations):
+        r, c = rc
+        this_ind = r * img_width + c
+        IND[i] = this_ind
+    IND.sort()
+    return IND.astype(int)
+
+
+def _indices_to_locations(img_width, IND):
+    IND.sort()
+    num_targets = IND.size
+    SUB = np.zeros((num_targets, 2), dtype=int)
+    for i, ind in enumerate(IND):
+        r = int(np.floor(ind / img_width))
+        c = int(ind % img_width)
+        SUB[i, :] = [r, c]
+    return SUB
+
+
+def _top_n_locations(C, num_targets):
+    cv = np.copy(C).flatten()
+    si = cv.argsort()
+    IND = si[-num_targets:]
+    IND.sort()
+    return IND
+
+
+def _top_n_locations_robust(C, num_targets):
+    CC = np.copy(C)
+    SUB = np.zeros((num_targets, 2), dtype=int)
+    for i in range(num_targets):
+        MC = np.where(CC==CC.max())
+        r, c = MC[0][0], MC[1][0]
+        SUB[i, :] = [r, c]
+        # set 5 x 5 area centered on (r, c) to 0
+        CC[r-1, c-1] = 0
+        CC[r-1, c+0] = 0
+        CC[r-1, c+1] = 0
+        CC[r+0, c-1] = 0
+        CC[r+0, c+0] = 0
+        CC[r+0, c+1] = 0
+        CC[r+1, c-1] = 0
+        CC[r+1, c+0] = 0
+        CC[r+1, c+1] = 0
+
+        CC[r-2, c-2] = 0
+        CC[r-2, c-1] = 0
+        CC[r-2, c-0] = 0
+        CC[r-2, c+1] = 0
+        CC[r-2, c+2] = 0
+
+        CC[r-1, c-2] = 0
+        CC[r-1, c+2] = 0
+
+        CC[r-0, c-2] = 0
+        CC[r-0, c+2] = 0
+
+        CC[r+1, c-2] = 0
+        CC[r+1, c+2] = 0
+
+        CC[r+2, c-2] = 0
+        CC[r+2, c-1] = 0
+        CC[r+2, c-0] = 0
+        CC[r+2, c+1] = 0
+        CC[r+2, c+2] = 0
+    IND = _locations_to_indices(CC.shape[1], SUB)
+    SUB = _indices_to_locations(CC.shape[1], IND)
+    return SUB, IND
+
+
+def _distances_of_best_matched_points(locations, top_locations):
+    # every location matched with every estimated location
+    num_targets = locations.shape[0]
+    O = locations
+    N = top_locations
+    DELTA = np.kron(O, np.ones((num_targets, 1))) - np.tile(N, (num_targets, 1))
+    DIST = np.sqrt((DELTA**2).sum(axis=1))
+    D = DIST.reshape((num_targets, num_targets))
+
+    # distances between points and estimated points giving best-match
+    MIN_D = np.zeros((num_targets,))
+    for di in range(num_targets):
+        MIN_D[di] = D.min();
+        locs = np.where(D==D.min())
+        R, C = locs[0][0], locs[1][0]
+        D[R,:] = np.inf
+        D[:,C] = np.inf
+    return MIN_D
+
+
+#################################################################
+#  DEFINE FUNCTIONS USED FOR UNIT TESTING
+#################################################################
+def test_bilin_with_integer_coordinates():
+    """Simple test where warped image should be same as original."""
+    im = np.array([[1, 2], [3, 4]])
+    xy = (np.array([0, 1, 0, 1]), np.array([0, 0, 1, 1]))
+    nRGB = 1
+    RGBsub = np.array([0, 0, 0, 0])
+    out = bilin(im, xy, nRGB, RGBsub)
+    expected_output = im.flatten()
+    assert np.allclose(out, expected_output)
+
+
+def test_bilin_with_integer_coordinates_rgb():
+    """Simple test where warped RGB image should be same as original."""
+    im = np.array([[1, 2], [3, 4]])
+    xy = (np.array([0, 1, 0, 1]), np.array([0, 0, 1, 1]))
+    nRGB = 3
+    RGB = np.stack((im, ) * 3, axis=-1)
+    RGBsub = np.array([0, 0, 0, 0])
+    for i in range(1, nRGB):
+        append_this = np.ones((4,)) * i
+        RGBsub = np.hstack((RGBsub, append_this))
+    RGBsub = RGBsub.astype(int)
+    out = bilin(RGB, xy, nRGB, RGBsub)
+
+    pixarr = _make_pixarr([0, 1])
+    pixarr_tiled = np.tile(pixarr, (3, 1))
+    expected_output = RGB[pixarr_tiled[:, 1], pixarr_tiled[:, 0], RGBsub]
+    assert np.allclose(out, expected_output)
+
+
+def test_bilin_with_real_valued_coordinates():
+    """Expected warped image is easy to calculate by hand."""
+    im = np.array([[28, 24], [16, 28]])
+    xy = ([0.75], [0.60])
+    nRGB = 1
+    RGBsub = [0]
+    out = bilin(im, xy, nRGB, RGBsub)
+
+    p = xy[0][0]
+    linear1 = (1 - p) * im[0, 0] + p * im[0, 1]
+    linear2 = (1 - p) * im[1, 0] + p * im[1, 1]
+    p = xy[1][0]
+    expected_output = (1 - p) * linear1 + p * linear2
+    assert np.allclose(out[0], expected_output)
+
+
+def test_pawarp():
+    # Parameters - input image with targets centered on landmarks (locations)
+    im_size = 128           # length of square image, pixels
+    num_targets = 3         # number of targets
+    min_target_dist = 32    # minimum distance between landmarks, pixels
+
+    # Parameters - warped version of input image
+    change_range = 8        # range of random shift in landmark position, pixels
+    max_value=im_size-1     # maximum x and y position. minimum always 0.
+
+    # Parameters - test
+    iterations = 1000
+    ALL_D = np.zeros((iterations, num_targets))
+
+    # Perform multiple tests.
+    for this_it in range(iterations):
+        # Create image with cross-shaped targets
+        locations, target_indices = _random_locations(im_size, num_targets, min_target_dist)
+        img, target = _image_with_donut_targets(im_size, locations)
+
+        # # Ensure that all helper functions are working properly.
+        # # Should be able to find exact target positions using convolution.
+        # C = fft_convolve2d(img, target)
+        # top_indices = top_n_locations(C, num_targets)
+        # working_functions = (top_indices==target_indices).all()
+        # assert working_functions, "Helper functions do not work: Cannot interpret test."
+
+        # Warp centers of targets to slightly different locations
+        new_locations = _perturb_locations(locations, max_value, change_range)
+        wimg, tri, inpix, fwdwarpix = pawarp(img, base=new_locations, target=locations, interp='bilin')
+
+        # Recover the original image by warping back
+        wwimg, tri, inpix, fwdwarpix = pawarp(wimg, base=locations, target=new_locations, interp='bilin')
+
+        # Look for the targets in the recovered image
+        C = _fft_convolve2d(wwimg, target)
+        estimated_locations, top_indices = _top_n_locations_robust(C, num_targets)
+
+        # plt_1 = plt.figure(figsize=(10,10))
+        # plt.imshow(wwimg, cmap="gray")
+        # plt.plot(locations[:,1], locations[:,0], 'g.', markersize=24, alpha=0.5)
+        # plt.plot(estimated_locations[:,1], estimated_locations[:,0], 'r+', markersize=24, alpha=0.5)
+        # plt.show()
+
+        best_distances = _distances_of_best_matched_points(locations, estimated_locations)
+        # print("Distances of best-matched points: ", best_distances)
+        # print(this_it)
+
+        ALL_D[this_it, :] = best_distances
+
+    # Evaluate
+    ALL_D = ALL_D.flatten()
+    Q95_less_than_1_pixel = np.quantile(ALL_D, 0.95) < 1
+    max_offset_less_than_perturbation = ALL_D.max() < change_range
+    PASS = Q95_less_than_1_pixel and max_offset_less_than_perturbation
+    assert PASS
+#################################################################
+#  UNIT TESTS
+#################################################################
+test_bilin_with_integer_coordinates()
+test_bilin_with_integer_coordinates_rgb()
+test_bilin_with_real_valued_coordinates()
+test_pawarp()

alignfaces/warp_tools.py

@@ -0,0 +1,279 @@
+import numpy as np
+from scipy.spatial import Delaunay
+
+
+# bilinear interpolation
+#
+# input:
+#   array   image, numpy array.
+#   xy      image coordinates, positive real valued, tuple of arrays.
+#           (length is number of pixels in array)
+#   nRGB    number of color channels (third dimension of array).
+#   RGBsub  channel index for each pixel in array, numpy array
+#           (length is number of pixels in array)
+def bilin(array, xy, nRGB, RGBsub):
+
+    assert (array.ndim == 2) or (array.ndim == 3)
+    if (array.ndim == 3):
+        assert (array.shape[2] == nRGB)
+    assert (len(RGBsub) == len(xy[0]) * nRGB)
+
+    # Zero padding.
+    # Handles solution to bad cases where subscripts pushed beyond image.
+    if nRGB == 1:
+        array = np.hstack((array, np.zeros((array.shape[0], 1))))
+        array = np.vstack((array, np.zeros((1, array.shape[1]))))
+    else:
+        #
+        # above works for single-channel grayscale.
+        # now for RGB
+        # print("In bilin:")
+        # print(array.shape)
+        # print(np.zeros((nRGB, array.shape[0], 1)).shape)
+        # array = np.concatenate((array,
+        #                         np.zeros((nRGB, array.shape[0], 1))), axis=2)
+        # array = np.concatenate((array,
+        #                         np.zeros((nRGB, 1, array.shape[1]))), axis=1)
+        array = np.concatenate((array,
+                                np.zeros((array.shape[0], 1, nRGB))), axis=1)
+        array = np.concatenate((array,
+                                np.zeros((1, array.shape[1], nRGB))), axis=0)
+
+    xy = (np.tile(xy[0], (nRGB, 1)).flatten(),
+          np.tile(xy[1], (nRGB, 1)).flatten())
+
+    ur = (np.ceil(xy[0]).astype(int), np.floor(xy[1]).astype(int))
+    ul = (np.floor(xy[0]).astype(int), np.floor(xy[1]).astype(int))
+    br = (np.ceil(xy[0]).astype(int), np.ceil(xy[1]).astype(int))
+    bl = (np.floor(xy[0]).astype(int), np.ceil(xy[1]).astype(int))
+
+    bad = br[0] == ul[0]
+    ur[0][bad] += 1
+    br[0][bad] += 1
+
+    bad = bl[1] == ul[1]
+    br[1][bad] += 1
+    bl[1][bad] += 1
+
+    indbl = np.ravel_multi_index((bl[1], bl[0], RGBsub),
+                                 (array.shape[0], array.shape[1], nRGB))
+    indbr = np.ravel_multi_index((br[1], br[0], RGBsub),
+                                 (array.shape[0], array.shape[1], nRGB))
+    indul = np.ravel_multi_index((ul[1], ul[0], RGBsub),
+                                 (array.shape[0], array.shape[1], nRGB))
+    indur = np.ravel_multi_index((ur[1], ur[0], RGBsub),
+                                 (array.shape[0], array.shape[1], nRGB))
+
+    vecarray = array.flatten()
+
+    denom = br[0] - bl[0]
+    num_a = br[0] - xy[0]
+    num_b = xy[0] - bl[0]
+    x1out = ((num_a / denom) * vecarray[indbl] +
+             (num_b / denom) * vecarray[indbr])
+
+    x2out = ((num_a / denom) * vecarray[indul] +
+             (num_b / denom) * vecarray[indur])
+
+    denom = ul[1] - bl[1]
+    num_a = ul[1] - xy[1]
+    num_b = xy[1] - bl[1]
+    out = (num_a / denom) * x1out + (num_b / denom) * x2out
+    return out
+
+
+# piecewise affine warp of target image ''im'' from target to base coords.
+#
+# input:
+#   im      image, numpy array.
+#   base    landmarks, rows are [x,y] points, numpy array.
+#   target  landmarks, rows are [x,y] points, numpy array.
+def pawarp(im, base, target, interp='bilin'):
+    # base & target should be numpy arrays, vertices X coordinate [x/y]
+    isuint8 = False
+    if (im.dtype == 'uint8'):
+        isuint8 = True
+    assert (im.ndim == 2) or (im.ndim == 3)
+    if (im.ndim == 3):
+        nRGB = im.shape[2]
+    else:
+        nRGB = 1
+    imdims = (im.shape[0], im.shape[1])
+    warpim = np.zeros((im.shape[0], im.shape[1], nRGB))
+
+    nverts = base.shape[0]
+    nverts2 = target.shape[0]
+    assert (nverts == nverts2)
+
+    boxpix = np.array([[1, 1], [1, imdims[0]],
+                      [imdims[1], 1], [imdims[1], imdims[0]]])
+    boxpix -= 1
+
+    pix1 = base.astype(float)
+    pix2 = target.astype(float)
+
+    pix1 = np.vstack((pix1, boxpix))
+    pix2 = np.vstack((pix2, boxpix))
+
+    # Perform Delaunay triangulation on pixel coordinates of base vertices.
+    dt = Delaunay(pix1)
+    tri = dt.simplices
+    ntri = tri.shape[0]
+
+    # Get the first, second, and third vertex for each triangle (x--coords).
+    xio = pix1[tri[:, 0], 0]
+    xi = pix2[tri[:, 0], 0]
+    xjo = pix1[tri[:, 1], 0]
+    xj = pix2[tri[:, 1], 0]
+    xko = pix1[tri[:, 2], 0]
+    xk = pix2[tri[:, 2], 0]
+
+    # Get the first, second, and third vertex for each triangle (y--coords).
+    yio = pix1[tri[:, 0], 1]
+    yi = pix2[tri[:, 0], 1]
+    yjo = pix1[tri[:, 1], 1]
+    yj = pix2[tri[:, 1], 1]
+    yko = pix1[tri[:, 2], 1]
+    yk = pix2[tri[:, 2], 1]
+
+    # Array for warp parameters (one set of params per triangle).
+    # a_i for i in 1 to 6, in equation 28 of Matthews & Baker on page 145.
+    wparams = np.zeros((ntri, 6))
+
+    # Calculate warp parameters for each triangle.
+    denom = (xjo - xio) * (yko - yio) - (yjo - yio) * (xko - xio)
+
+    wparams[:, 0] = ((xio * ((xk - xi) * (yjo - yio) - (xj - xi) * (yko - yio)) +
+                     yio * ((xj - xi) * (xko - xio) - (xk - xi) * (xjo - xio))) /
+                     denom + xi)
+
+    wparams[:, 3] = ((xio * ((yk - yi) * (yjo - yio) - (yj - yi) * (yko - yio)) +
+                     yio * ((yj - yi) * (xko - xio) - (yk - yi) * (xjo - xio))) /
+                     denom + yi)
+
+    wparams[:, 1] = ((xj - xi) * (yko - yio) - (xk - xi) * (yjo - yio)) / denom
+
+    wparams[:, 4] = ((yj - yi) * (yko - yio) - (yk - yi) * (yjo - yio)) / denom
+
+    wparams[:, 2] = ((xk - xi) * (xjo - xio) - (xj - xi) * (xko - xio)) / denom
+
+    wparams[:, 5] = ((yk - yi) * (xjo - xio) - (yj - yi) * (xko - xio)) / denom
+
+    # Determine square bounds of pixels inside base mesh.
+    xmx = int(min(np.ceil(pix1[:, 0].max()), imdims[1]))
+    xmn = int(max(np.floor(pix1[:, 0].min()), 0))
+    ymx = int(min(np.ceil(pix1[:, 1].max()), imdims[0]))
+    ymn = int(max(np.floor(pix1[:, 1].min()), 0))
+
+    # Array for pixel coordinates inside base mesh.
+    npix = im[ymn:ymx + 1, xmn:xmx + 1].size
+    pixarr = np.zeros((npix, 2))
+
+    x = np.arange(xmn, xmx + 1)
+    y = np.arange(ymn, ymx + 1)
+    xx, yy = np.meshgrid(x, y)
+    pixarr = (xx.flatten(), yy.flatten())
+    # pixind = np.ravel_multi_index((pixarr[1], pixarr[0]), imdims)
+
+    pixarr = np.transpose(np.array(pixarr))
+    inpix = dt.find_simplex(pixarr)
+
+    # Get only those pixels that are inside the convex hull.
+    isin = np.argwhere(inpix >= 0)[:, 0]
+
+    # Warp parameters for each pixel inside convex hull.
+    wp = wparams[inpix[isin], :]
+
+    fwdx = wp[:, 0] + wp[:, 1] * pixarr[isin, 0] + wp[:, 2] * pixarr[isin, 1]
+    fwdy = wp[:, 3] + wp[:, 4] * pixarr[isin, 0] + wp[:, 5] * pixarr[isin, 1]
+    if interp == 'nearest':
+        fwdx = fwdx.round().astype(int)
+        fwdy = fwdy.round().astype(int)
+
+    fwdwarpix = np.transpose(np.vstack((fwdx, fwdy)))
+
+    fwdwarpix[fwdwarpix[:, 0] < 1, 0] = 1
+    fwdwarpix[fwdwarpix[:, 1] < 1, 1] = 1
+
+    fwdwarpix[np.isnan(fwdwarpix[:, 0]), 0] = 1
+    fwdwarpix[np.isnan(fwdwarpix[:, 1]), 1] = 1
+
+    fwdwarpix[fwdwarpix[:, 0] > imdims[1], 0] = imdims[1]
+    fwdwarpix[fwdwarpix[:, 1] > imdims[0], 1] = imdims[0]
+
+    RGBsub = np.empty((1, 1))
+    for RGB in range(nRGB):
+        this_channel = np.ones((fwdwarpix.shape[0], 1)) * RGB
+        RGBsub = np.vstack((RGBsub, this_channel))
+    RGBsub = np.delete(RGBsub, (0), axis=0)
+    RGBsub = RGBsub.astype(int).flatten()
+
+    pixx = np.tile(pixarr[isin, 0], (nRGB, 1)).flatten()
+    pixy = np.tile(pixarr[isin, 1], (nRGB, 1)).flatten()
+    # alldims = (imdims[0], imdims[1], nRGB)
+    # pixind = np.ravel_multi_index((pixy, pixx, RGBsub), alldims)
+    # print("pixarr should be tiled by channel regardless of method.")
+    # print("input fwdwarpix_tup grayscale for bilin.")
+    # print("fwdwarpix tiled for nearest neighbor.")
+    # print("pixx.shape, pixy.shape: \t")
+    # print(pixx.shape)
+    # print(pixy.shape)
+    # print("pixarr.shape: \t")
+    # print(pixarr.shape)
+
+    # Pixarr is now expanded by channel.
+    # Same as before in the case of grayscale image.
+    pixarr = np.vstack((pixx, pixy)).transpose()
+
+    if interp == 'nearest':
+        # fwdwarpind = sub2ind([imdims nRGB], repmat(fwdwarpix(:,2),[nRGB 1]),
+                        # repmat(fwdwarpix(:,1),[nRGB 1]), RGBsub);
+        print("Nearest neighbor to do:")
+        print("In Matlab, we would derive fwdwarpind.")
+        print("In this case, expand pixarr & fwdwarpix across RGB channels.")
+    if nRGB > 1:
+        warpim = np.zeros((imdims[0], imdims[1], nRGB))
+    else:
+        warpim = np.zeros(imdims)
+    if interp == 'nearest':
+        print("fwdwarpix already reduced by isin!")
+        print("To do: deal with that!")
+        # expand fwdwarpix across channels
+        # pixx = np.tile(pixarr[isin, 0], (nRGB, 1)).flatten()
+        # pixy = np.tile(pixarr[isin, 1], (nRGB, 1)).flatten()
+        # pixarr = np.vstack((pixx, pixy)).transpose()
+        fwdx = np.tile(fwdwarpix[:, 0], (nRGB, 1)).flatten()
+        fwdy = np.tile(fwdwarpix[:, 1], (nRGB, 1)).flatten()
+        fwdwarpix = np.vstack((fwdx, fwdy)).transpose()
+
+        print("Indexing for 3rd dimension, if there is one!")
+        if nRGB > 1:
+            warpim[pixarr[:, 1], pixarr[:, 0], RGBsub] = im[fwdwarpix[:, 1],
+                                                            fwdwarpix[:, 0],
+                                                            RGBsub]
+        else:
+            warpim[pixarr[:, 1], pixarr[:, 0]] = im[fwdwarpix[:, 1],
+                                                    fwdwarpix[:, 0]]
+    else:
+        # print("now, pixarr is already reduced by isin!")
+        # print("To do: deal with that!")
+        #
+        # print("RGBsub.shape")
+        # print(RGBsub.shape)
+
+        fwdwarpix_tup = (fwdwarpix[:, 0], fwdwarpix[:, 1])
+        out = bilin(im, fwdwarpix_tup, nRGB, RGBsub)
+
+        # print("Indexing for 3rd dimension, if there is one!")
+        if nRGB > 1:
+            warpim[pixarr[:, 1], pixarr[:, 0], RGBsub] = out
+        else:
+            warpim[pixarr[:, 1], pixarr[:, 0]] = out
+
+    if isuint8:
+        warpim = warpim.astype(np.uint8)
+    return warpim, tri, inpix, fwdwarpix
+# -----------------------------------------------------------------------------
+
+
+# print("All above - final warp code in /warp_tests/")