import numpy as np
import imageio
import matplotlib.pyplot as plt
import scipy.ndimage as img

def imageRead(imgname, pilmode='L', arrtype=np.float):
    """
    pilmode: str
        for luminance / intesity images use 'L'
        for RGB color images use 'RGB'
    arrtype: numpy dtype
        use np.float, np.uint8, ...
    """
    return imageio.imread(imgname, pilmode=pilmode).astype(arrtype)

def imageWrite(arrF, imgname, arrtype=np.uint8):
    imageio.imwrite(imgname, arrF.astype(arrtype))

/tmp/ipykernel_2184682/3362905083.py:1: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.
Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations
  def imageRead(imgname, pilmode='L', arrtype=np.float):

arrF = imageRead("Data/asterix.png")
_ = plt.imshow(arrF, cmap="gray")

def push_warp(arrF):
    M, N = arrF.shape
    arrG = np.zeros_like(arrF)
    for y in range(M):
        for x in range(N):
            u = int(4.0 * x)
            v = y
            if u<N:
                arrG[v, u] = arrF[y, x]
    return arrG

arrF = imageRead("Data/asterix.png")
arrG = push_warp(arrF)
_ = plt.imshow(arrG, cmap="gray")

def pull_warp(arrF, interpolation="nearest"):
    M, N = arrF.shape
    arrG = np.zeros_like(arrF)
    for v in range(M):
        for u in range(N):
            x = u / 4.0
            y = v
            
            if interpolation=="nearest":
                nearest_x = np.round(x)  
                arrG[v,u] = arrF[y, int(nearest_x)]
            
            elif interpolation=="linear":
                x_up = np.ceil(x)
                x_down = np.floor(x)
                if x_up != x_down:
                    delta = (x - x_down) * (arrF[y, int(x_up)] - arrF[y, int(x_down)]) / (x_up - x_down)
                    arrG[v,u] = arrF[y, int(x_down)] + int(delta)
                else:
                    arrG[v,u] = arrF[y, int(x)]
            
    return arrG

arrF = imageRead("Data/asterix.png")
arrG = pull_warp(arrF, interpolation="linear")
_ = plt.imshow(arrG, cmap="gray")

# Without For Loop
def pull_warp_2(arrF):
    M, N = arrF.shape
    u, v = np.meshgrid(M, N)
    
    arrG = np.zeros_like(arrF)
     
    x = u / 4.0
    y = v

    # Nearest-neighbor interpolation
    nearest_x = np.round(x)  
    arrG[v,u] = arrF[y, int(nearest_x)]
                    
    return arrG

arrF = imageRead("Data/asterix.png")
arrG = pull_warp(arrF, interpolation="linear")
_ = plt.imshow(arrG, cmap="gray")

def delta1(r, sigma):
    return np.where(r < sigma, 1 - r/sigma, 0)

def delta2(r, sigma):
    return np.where(r < sigma, 1 - r**2/sigma**2, 0)

def delta3(r, sigma):
    return np.where(r < sigma, np.sqrt(np.abs(sigma**2 - r**2)) / sigma, 0)

def delta4(r, sigma):
    return 1 - np.tanh(r/sigma)

def delta5(r, sigma):
    return np.exp(-0.5 * (r/sigma)**2)

def fisheye(arrF, vecC, sigma=100., dfct=delta1):
    vecC = np.array(vecC).reshape(-1,1)
    M, N = arrF.shape
    u, v = np.meshgrid(np.arange(N), np.arange(M))
    matX = np.vstack((v.flatten(), u.flatten())).astype(float) # u
    matR = vecC - matX                      # vectors pointing to center # r = c-u
    dist = np.sqrt(np.sum(matR**2, axis=0)) # distances to center # ||r||
    matX = matX + matR * dfct(dist, sigma)  # W(u,c,sigma)= u + r*delta
    
    arrG = img.map_coordinates(arrF, matX)  # matX MUST be float
    arrG = arrG.reshape(M,N)
    return arrG

white_cols = np.linspace(0, arrF.shape[1]-16, 16).astype(int)
white_rows = np.linspace(0, arrF.shape[0]-16, 16).astype(int)

black_img = np.zeros_like(arrF)
for i in range(4):
    black_img[white_rows+i]=255
    black_img[:, white_cols+i]=255
#_ = plt.imshow(black_img / 255, cmap='gray')

fig, axs = plt.subplots(2,3, figsize=(20,10))
axs = axs.flatten()

axs[0].imshow(black_img / 255, cmap="gray", vmin=0, vmax=1)
axs[0].title.set_text('Original Image')

out = fisheye(black_img,(black_img.shape[0]//2,black_img.shape[1]//2), sigma=300, dfct=delta1)
axs[1].title.set_text('Delta 1'); axs[1].imshow(out / 255, cmap="gray", vmin=0, vmax=1)

out = fisheye(black_img,(black_img.shape[0]//2,black_img.shape[1]//2), sigma=300, dfct=delta2)
axs[2].title.set_text('Delta 2'); axs[2].imshow(out / 255, cmap="gray", vmin=0, vmax=1)

out = fisheye(black_img,(black_img.shape[0]//2,black_img.shape[1]//2), sigma=300, dfct=delta3)
axs[3].title.set_text('Delta 2'); axs[3].imshow(out / 255, cmap="gray", vmin=0, vmax=1)

out = fisheye(black_img,(black_img.shape[0]//2,black_img.shape[1]//2), sigma=300, dfct=delta4)
axs[4].title.set_text('Delta 4'); axs[4].imshow(out / 255, cmap="gray", vmin=0, vmax=1)

out = fisheye(black_img,(black_img.shape[0]//2,black_img.shape[1]//2), sigma=300, dfct=delta5)
axs[5].title.set_text('Delta 5'); _ = axs[5].imshow(out / 255, cmap="gray", vmin=0, vmax=1)

fig.tight_layout()

arrF = imageRead('Data/asterix.png')
fig, axs = plt.subplots(1, 2, figsize=(15,15))

out = fisheye(arrF, (400, 650))
axs[0].imshow(out / 255, cmap="gray", vmin=0, vmax=1)
axs[0].title.set_text('Center of force: (400,650)')

out = fisheye(arrF, (350, 200), sigma=300)
axs[1].imshow(out / 255, cmap="gray", vmin=0, vmax=1)
_ = axs[1].title.set_text('Center of force: (350,200)')

def lpNorm(matX, p):
    return np.power(np.sum(np.power(np.abs(matX), p), axis=0), 1/p)

def imageWarp(arrF, vecC, sigma, p):
    vecC = np.array(vecC).reshape(-1,1)
    M, N = arrF.shape
    u, v = np.meshgrid(np.arange(N), np.arange(M))
    
    matX = np.vstack((v.flatten(), u.flatten())).astype(float) 
    matR = vecC - matX     # vectors pointing to center
    matX = matX + matR * np.exp(-lpNorm(matR, p)**2 / (2*sigma**2))
    
    arrG = img.map_coordinates(arrF, matX)
    arrG = arrG.reshape(M,N)
    return np.clip(arrG,0,255)

arrF = imageRead("Data/lena.png")
vecC = np.array([350,300])  #np.array([150,128])
sigma = [50, 50, 100]
p_values = [3, 12, 12]

fig, axs = plt.subplots(1, 3, figsize=(15,15))

for i, (s,p) in enumerate(zip(sigma, p_values)):
    out = imageWarp(arrF, vecC=vecC, sigma=s, p=p)
    axs[i].imshow(out/255, cmap="gray")

arrF = imageRead("Data/cat1.png")
print("image.shape: ", arrF.shape)

vecC = np.array([128,116])
sigma = [50, 75, 100]
p_values = [3, 12, 24]

fig, axs = plt.subplots(1, 3, figsize=(15,15))

for i, (s,p) in enumerate(zip(sigma, p_values)):
    out = imageWarp(arrF, vecC=vecC, sigma=s, p=p)
    axs[i].imshow(out/255, cmap="gray")

image.shape:  (256, 232)

def custom_swirl_effect(arrF):
    M, N = arrF.shape
    u, v = np.meshgrid(np.arange(N), np.arange(M))
    matX = np.stack((v, u)).astype(float)
    
    # compute polar coordinates with respect to vecC
    vecC = np.array([350, 200]).reshape(2,1,1)
    diff = matX - vecC 
    r = np.linalg.norm(diff, axis=0)
    angle = np.arctan2(diff[1], diff[0])
    
    dist = r/r.max()
    sigma = 0.1
    gaussian = np.exp(- dist**2 / (2*(sigma**2)))
    plt.imshow(gaussian)
    plt.title("gaussian")
    plt.show()
    
    magnitude = 6
    angle += magnitude*gaussian
    
    # compute euclidian coordinates with respect to image zero
    matX = np.stack([r * np.cos(angle) , r * np.sin(angle)])
    matX += vecC

    arrG = img.map_coordinates(arrF, matX) # matX MUST be float
    arrG = arrG.reshape(M,N)
    return arrG

arrF = imageRead('Data/asterix.png')
out = custom_swirl_effect(arrF)
_ = plt.imshow(out / 255, cmap="gray")

def waves_effect(arrF, amplitude, frequency, phase, debug=False):
    M, N = arrF.shape
    u, v = np.meshgrid(np.arange(N+amplitude[1]*2), np.arange(M+amplitude[0]*2))
    matX = np.stack((v, u)).astype(float)
      
    # for j axis
    b = amplitude[1] * np.sin(matX[0]/frequency[1] + phase[1])
    matX[1] += b - amplitude[1]
    
    # for i axis
    a = amplitude[0] * np.sin(matX[1]/frequency[0] + phase[0]) 
    matX[0] += a - amplitude[0]
    
    if debug:
        plt.imshow(a); plt.show()
        plt.imshow(b); plt.show()
    
    arrG = img.map_coordinates(arrF, matX) # matX MUST be float
    arrG = arrG.reshape(matX.shape[1],matX.shape[2])
    return arrG

arrF = imageRead('Data/lena.png')
out = waves_effect(arrF, amplitude=[10,7], frequency=[10.0,6.5], phase=[0,2], debug=True)
plt.imshow(out / 255, cmap="gray")
plt.axis("off")
plt.show()

arrF = imageRead('Data/lena.png')

out1 = waves_effect(arrF, amplitude=[10,10], frequency=[20,20], phase=[5,0])
out2 = waves_effect(arrF, amplitude=[10,7], frequency=[10.0,6.5], phase=[0,3.5])
out3 = waves_effect(arrF, amplitude=[10,10], frequency=[5.0,40], phase=[0,np.pi])

fig, axs = plt.subplots(1, 3, figsize=(15,15))

axs[0].imshow(out1 / 255, cmap="gray"); axs[0].axis("off")
axs[1].imshow(out2 / 255, cmap="gray"); axs[1].axis("off")
axs[2].imshow(out3 / 255, cmap="gray"); _ = axs[2].axis("off")

arrF = imageRead('Data/clock.jpg')
out1 = waves_effect(arrF, amplitude=[10,10], frequency=[20,20], phase=[5,0])
out2 = waves_effect(arrF, amplitude=[10,7], frequency=[10.0,6.5], phase=[0,3.5])
out3 = waves_effect(arrF, amplitude=[10,10], frequency=[5.0,40], phase=[0,np.pi])

fig, axs = plt.subplots(1, 4, figsize=(15,10))
axs[0].imshow(arrF / 255, cmap="gray"); axs[0].axis("off")
axs[1].imshow(out1 / 255, cmap="gray"); axs[1].axis("off")
axs[2].imshow(out2 / 255, cmap="gray"); axs[2].axis("off")
axs[3].imshow(out3 / 255, cmap="gray"); _ = axs[3].axis("off")
#To save the images
#imageWrite(out1, save_dir + "Task6-2.png")

def cylinder(arrF, debug=False):
    M, N = arrF.shape
    u, v = np.meshgrid(np.arange(N), np.arange(M))
    matX = np.stack((v, u)).astype(float)
    
    # compute polar coordinates with respect to vecC
    vecC = np.array([arrF.shape[0]//2, arrF.shape[1]//2]).reshape(2,1,1)
    diff = matX - vecC 
    
    r = np.linalg.norm(diff, axis=0)
    #y = (1 - r/(arrF.shape[0]//2)) * (arrF.shape[0]-1)
    y = (r/(arrF.shape[0]//2)) * (arrF.shape[0]-1) 
    
    angle = np.arctan2(diff[0], diff[1])
    angle = angle-angle.min() # min angle is 0 with this line
    angle = angle/angle.max() # angle is normalized to 0-1
    x = angle * (arrF.shape[1]-1)
    
    if debug:
        plt.imshow(y); plt.show()
        plt.imshow(x); plt.show()

    matX = np.stack([y, x])
    
    #arrG = img.map_coordinates(arrF, matX) # matX MUST be float
    arrG = img.map_coordinates(np.flipud(arrF), matX) # matX MUST be float
    arrG = arrG.reshape(M,N)
    return arrG

arrF = imageRead("Data/flower.png")
out = cylinder(arrF, debug=True)
plt.imshow(out / 255, cmap="gray")
plt.show()

def cylinder_with_hole(arrF, debug=False):
    M, N = arrF.shape
    u, v = np.meshgrid(np.arange(min(M, N)), np.arange(min(M, N)))
    matX = np.stack((v, u)).astype(float)
    
    # compute polar coordinates with respect to vecC
    vecC = np.array([min(M, N)//2, min(M, N)//2]).reshape(2,1,1)
    diff = matX - vecC 
    
    r = np.linalg.norm(diff, axis=0)
    #r = (1 - r/(arrF.shape[0]//2)) * (arrF.shape[0]-1)+60
    #r = (1 - r/(arrF.shape[0]//2-30)) * (arrF.shape[0]-1) + 60
    r = (1 - r/(min(M, N)//2-30)) * (min(M, N)-1) + 60
    
    angle = np.arctan2(diff[0], diff[1])
    angle = angle-angle.min()
    angle = angle/angle.max() * (arrF.shape[1]-1)
    
    if debug:
        fig, axs = plt.subplots(1, 3, figsize=(15,15))
        axs[0].imshow(r); axs[0].title.set_text("r")
        axs[1].imshow(angle); axs[1].title.set_text("angle")
        
    matX = np.stack([r, angle])
    
    arrG = img.map_coordinates(arrF, matX) # matX MUST be float
    arrG = arrG.reshape(min(M, N),min(M, N))
    return arrG

arrF_ = imageRead('Data/asterix.png')
out = cylinder_with_hole(arrF_, debug=True)
plt.imshow(out / 255, cmap="gray"); plt.title("warped image")
plt.show()

arrF = imageRead('Data/flower.png')
out = cylinder_with_hole(arrF)

fig, axs = plt.subplots(1, 2, figsize=(10,10))

axs[0].imshow(arrF / 255, cmap="gray"); plt.axis("off"); plt.axis("off"); axs[0].title.set_text("original image")
axs[1].imshow(out / 255, cmap="gray"); plt.axis("off"); plt.axis("off"); axs[1].title.set_text("warped image")

def xy2rphi(x, y):
    r = np.sqrt(x**2 + y**2)
    phi = np.arctan2(y, x)
    return r, phi

def rphi2xy(r, phi):
    x = r * np.cos(phi)
    y = r * np.sin(phi)
    return x, y

def to_r_phi_plane_(f, m, n, rmax, phimax):
    
    rs, phis = np.meshgrid(np.linspace(0, rmax, n), np.linspace(0, phimax, m), sparse=True)
    
    xs, ys = rphi2xy(rs, phis)
    xs, ys = xs.reshape(-1), ys.reshape(-1)
    
    coords = np.vstack((ys, xs))
    #print(coords.shape)
    
    vecC = np.array([f.shape[0]//2, f.shape[1]//2]).reshape(2,1)
    coords += vecC
    
    g = img.map_coordinates(f, coords, order=3)
    g = g.reshape(m, n)
    return np.flipud(g)

def from_r_phi_plane_V2_(g, m, n, rmax, phimax):
    xs, ys = np.meshgrid(np.arange(n), np.arange(m), sparse=True)
    
    xs -= n//2
    ys -= m//2
    
    rs, phis = xy2rphi(xs, ys)
    #print(rs, phis)
    phis += np.pi

    rs, phis = rs.reshape(-1), phis.reshape(-1)
     
    iis = phis / phimax * (m-1)
    jjs = rs / rmax * (n-1)
    coords = np.vstack((iis, jjs)) 
    #print(iis, jjs)
    
    h = img.map_coordinates(g, coords, order=3)
    h = h.reshape(m, n)
    return np.fliplr(np.flipud(h))

fig, axs = plt.subplots(1, 4, figsize=(15,15))

f = imageRead('Data/clock.jpg')
axs[0].imshow(f / 255, cmap="gray"); axs[0].axis("off")

f = np.flipud(f)
m, n = f.shape
rmax = np.sqrt((m/2)**2 + (n/2)**2)
phimax = 2 * np.pi

g = to_r_phi_plane_(f, m, n, rmax, phimax)
axs[1].imshow(g / 255, cmap="gray"); axs[1].axis("off")

blurred_g = img.gaussian_filter1d(g, sigma=6, axis=0, mode="wrap")
axs[2].imshow(blurred_g / 255, cmap="gray"); axs[2].axis("off")

#g = np.flipud(g)
h = from_r_phi_plane_V2_(blurred_g, m, n, rmax, phimax)
axs[3].imshow(h / 255, cmap="gray"); _ = axs[3].axis("off")

f = imageRead('Data/clock.jpg')

f = np.flipud(f)
m, n = f.shape
rmax = np.sqrt((m/2)**2 + (n/2)**2)
phimax = 2 * np.pi

g = to_r_phi_plane_(f, m, n, rmax, phimax)

fig, axs = plt.subplots(1, 4, figsize=(15,10))

blurred_g1 = img.gaussian_filter1d(g, sigma=2, axis=0, mode="wrap")
h1 = from_r_phi_plane_V2_(blurred_g1, m, n, rmax, phimax)
_ = axs[0].imshow(h1 / 255, cmap="gray"); _ = axs[0].axis("off")

blurred_g2 = img.gaussian_filter1d(g, sigma=6, axis=0, mode="wrap")
h2 = from_r_phi_plane_V2_(blurred_g2, m, n, rmax, phimax)
_ = axs[1].imshow(h2 / 255, cmap="gray"); _ = axs[1].axis("off")

blurred_g3 = img.gaussian_filter1d(g, sigma=12, axis=0, mode="wrap")
h3 = from_r_phi_plane_V2_(blurred_g3, m, n, rmax, phimax)
_ = axs[2].imshow(h3 / 255, cmap="gray"); _ = axs[2].axis("off")

blurred_g4 = img.gaussian_filter1d(g, sigma=24, axis=0, mode="wrap")
h4 = from_r_phi_plane_V2_(blurred_g4, m, n, rmax, phimax)
_ = axs[3].imshow(h4 / 255, cmap="gray"); _ = axs[3].axis("off")

#To save the images
#imageWrite(h2, save_dir + "Task6-4.png")

def bilinear_warp(arrF, arrH, u_ul, u_ur, u_ll, u_lr):
    M, N = arrH.shape
    u, v = np.meshgrid(np.arange(N), np.arange(M))
    matX = np.stack((u, v)).astype(float)
    
    u1, v1 = u_ul
    u2, v2 = u_ur
    u3, v3 = u_ll
    u4, v4 = u_lr
    
    x1, y1 = 0, 0
    x2, y2 = arrF.shape[1], 0
    x3, y3 = 0, arrF.shape[0]
    x4, y4 = arrF.shape[1], arrF.shape[0]
    
    A = [[u1*v1, u1, v1, 1, 0, 0, 0, 0],
         [u2*v2, u2, v2, 1, 0, 0, 0, 0],
         [u3*v3, u3, v3, 1, 0, 0, 0, 0],
         [u4*v4, u4, v4, 1, 0, 0, 0, 0],
         [0, 0, 0, 0, u1*v1, u1, v1, 1],
         [0, 0, 0, 0, u2*v2, u2, v2, 1],
         [0, 0, 0, 0, u3*v3, u3, v3, 1],
         [0, 0, 0, 0, u4*v4, u4, v4, 1]]
    A = np.array(A)
    b = np.array([x1, x2, x3, x4, y1, y2, y3, y4]).T
    X, _, _, _ = np.linalg.lstsq(A, b, rcond=None)
    a,b,c,d,e,f,g,h = X
    
    X_ = a*matX[0]*matX[1] + b*matX[0] + c*matX[1] + d
    Y_ = e*matX[0]*matX[1] + f*matX[0] + g*matX[1] + h
    
    matX = np.stack((Y_, X_))
    
    arrG = img.map_coordinates(arrF, matX, cval=-1) # matX MUST be float
    arrG = arrG.reshape(matX.shape[1],matX.shape[2])
    
    mask = arrG != -1
    newArr = arrH.copy()
    newArr[mask] = arrG[mask]
    return newArr

arrF = imageRead('Data/asterix.png')
arrH = imageRead('Data/isle.jpg')
out = bilinear_warp(arrF, arrH, (215, 56), (365, 10), (218, 258), (364, 296))
plt.subplots(figsize=(10,10))
plt.imshow(out / 255, cmap="gray"); plt.axis("off"); plt.show()

def perspective_mapping(arrF, arrH, u_ul, u_ur, u_ll, u_lr, debug=False):
    M, N = arrH.shape
    u, v = np.meshgrid(np.arange(N), np.arange(M))
    matX = np.stack((u, v)).astype(float)
    
    u1, v1 = u_ul
    u2, v2 = u_ur
    u3, v3 = u_ll
    u4, v4 = u_lr
    
    x1, y1 = 0, 0
    x2, y2 = arrF.shape[1], 0
    x3, y3 = 0, arrF.shape[0]
    x4, y4 = arrF.shape[1], arrF.shape[0]
    
    A = [[u1, v1, 1, 0, 0, 0, -u1*x1, -v1*x1],
         [u2, v2, 1, 0, 0, 0, -u2*x2, -v2*x2],
         [u3, v3, 1, 0, 0, 0, -u3*x3, -v3*x3],
         [u4, v4, 1, 0, 0, 0, -u4*x4, -v4*x4],
         [0, 0, 0, u1, v1, 1, -u1*y1, -v1*y1],
         [0, 0, 0, u2, v2, 1, -u2*y2, -v2*y2],
         [0, 0, 0, u3, v3, 1, -u3*y3, -v3*y3],
         [0, 0, 0, u4, v4, 1, -u4*y4, -v4*y4]]
    
    A = np.array(A)
    b = np.array([x1, x2, x3, x4, y1, y2, y3, y4]).T
    X, _, _, _ = np.linalg.lstsq(A, b, rcond=None)
    a,b,c,d,e,f,g,h = X
    
    X_ = (a*matX[0] + b*matX[1] + c) / (g*matX[0] + h*matX[1] + 1)
    Y_ = (d*matX[0] + e*matX[1] + f) / (g*matX[0] + h*matX[1] + 1)
    
    matX = np.stack((Y_, X_))
    
    arrG = img.map_coordinates(arrF, matX, cval=-1) # matX MUST be float
    arrG = arrG.reshape(matX.shape[1],matX.shape[2])
    
    mask = arrG != -1
    #mask = np.bitwise_and(arrG != -1, arrG<230)
    
    if debug:
        plt.imshow(arrG, cmap="gray"); plt.title("Transformed Image"); plt.show()
        plt.imshow(mask, cmap="gray"); plt.title("Mask")

    newArr = arrH.copy()
    newArr[mask] = arrG[mask]
    return newArr

def perspective_mapping_transparent(arrF, arrH, u_ul, u_ur, u_ll, u_lr, debug=False):
    M, N = arrH.shape
    u, v = np.meshgrid(np.arange(N), np.arange(M))
    matX = np.stack((u, v)).astype(float)
    
    u1, v1 = u_ul
    u2, v2 = u_ur
    u3, v3 = u_ll
    u4, v4 = u_lr
    
    x1, y1 = 0, 0
    x2, y2 = arrF.shape[1], 0
    x3, y3 = 0, arrF.shape[0]
    x4, y4 = arrF.shape[1], arrF.shape[0]
    
    A = [[u1, v1, 1, 0, 0, 0, -u1*x1, -v1*x1],
         [u2, v2, 1, 0, 0, 0, -u2*x2, -v2*x2],
         [u3, v3, 1, 0, 0, 0, -u3*x3, -v3*x3],
         [u4, v4, 1, 0, 0, 0, -u4*x4, -v4*x4],
         [0, 0, 0, u1, v1, 1, -u1*y1, -v1*y1],
         [0, 0, 0, u2, v2, 1, -u2*y2, -v2*y2],
         [0, 0, 0, u3, v3, 1, -u3*y3, -v3*y3],
         [0, 0, 0, u4, v4, 1, -u4*y4, -v4*y4]]
    
    A = np.array(A)
    b = np.array([x1, x2, x3, x4, y1, y2, y3, y4]).T
    X, _, _, _ = np.linalg.lstsq(A, b, rcond=None)
    a,b,c,d,e,f,g,h = X
     
    X_ = (a*matX[0] + b*matX[1] + c) / (g*matX[0] + h*matX[1] + 1)
    Y_ = (d*matX[0] + e*matX[1] + f) / (g*matX[0] + h*matX[1] + 1)
    
    matX = np.stack((Y_, X_))
    
    arrG = img.map_coordinates(arrF, matX, cval=-1) # matX MUST be float
    arrG = arrG.reshape(matX.shape[1],matX.shape[2])
    
    #mask = arrG != -1
    mask = np.bitwise_and(arrG != -1, arrG<230)
    
    if debug:
        plt.imshow(arrG, cmap="gray"); plt.title("Transformed Image"); plt.show()
        plt.imshow(mask, cmap="gray"); plt.title("Mask")

    newArr = arrH.copy()
    newArr[mask] = arrG[mask]
    return newArr

arrF_ = imageRead('Data/asterix.png')
arrH_ = imageRead('Data/isle.jpg')
out = perspective_mapping_transparent(arrF_, arrH_, (215, 56), (365, 10), (218, 258), (364, 296))
out2 = perspective_mapping(arrF_, arrH_, (215, 56), (365, 10), (218, 258), (364, 296))
fig, axs = plt.subplots(1, 2, figsize=(10,10))
axs[0].imshow(out / 255, cmap="gray")
axs[1].imshow(out2 / 255, cmap="gray")
plt.show()

arrF_ = imageRead('Data/clock.jpg')
arrH_ = imageRead('Data/isle.jpg')
out = perspective_mapping_transparent(arrF_, arrH_, (215, 56), (365, 10), (218, 258), (364, 296))
out2 = perspective_mapping(arrF_, arrH_, (215, 56), (365, 10), (218, 258), (364, 296))
fig, axs = plt.subplots(1, 2, figsize=(10,10))
axs[0].imshow(out / 255, cmap="gray")
axs[1].imshow(out2 / 255, cmap="gray")
plt.show()

#imageWrite(out, save_dir + "Task6-5.png")

Image Warping

Image Warping¶

Forward (PUSH) Warps¶

Backward (PULL) Warps¶

Fisheye Effect¶

Swirl Effect¶

Waves Effect¶

Cylinder Anamorphosis¶

Radial Blur Effect¶

Bilinear Warping¶

Perspective Mapping¶

Elif Cansu YILDIZ