Create utils.py

utils.py

@@ -0,0 +1,135 @@
+import numpy as np
+import cv2
+import PIL.Image
+from scipy.interpolate import griddata
+
+def RGB2gray(rgb):
+    r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
+    gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
+    return gray
+
+# Update img_to_patches to handle direct image input
+def img_to_patches(img: PIL.Image.Image) -> tuple:
+    patch_size = 16
+    img = img.convert('RGB')  # Ensure image is in RGB format
+
+    grayscale_imgs = []
+    imgs = []
+    coordinates = []
+
+    for i in range(0, img.height, patch_size):
+        for j in range(0, img.width, patch_size):
+            box = (j, i, j + patch_size, i + patch_size)
+            img_color = np.asarray(img.crop(box))
+            grayscale_image = cv2.cvtColor(src=img_color, code=cv2.COLOR_RGB2GRAY)
+            grayscale_imgs.append(grayscale_image.astype(dtype=np.int32))
+            imgs.append(img_color)
+            normalized_coord = (i + patch_size // 2, j + patch_size // 2)
+            coordinates.append(normalized_coord)
+
+    return grayscale_imgs, imgs, coordinates, (img.height, img.width)
+
+def get_l1(v):
+    return np.sum(np.abs(v[:, :-1] - v[:, 1:]))
+
+def get_l2(v):
+    return np.sum(np.abs(v[:-1, :] - v[1:, :]))
+
+def get_l3l4(v):
+    l3 = np.sum(np.abs(v[:-1, :-1] - v[1:, 1:]))
+    l4 = np.sum(np.abs(v[1:, :-1] - v[:-1, 1:]))
+    return l3 + l4
+
+def get_pixel_var_degree_for_patch(patch: np.array) -> int:
+    l1 = get_l1(patch)
+    l2 = get_l2(patch)
+    l3l4 = get_l3l4(patch)
+    return l1 + l2 + l3l4
+
+def get_rich_poor_patches(img: PIL.Image.Image, coloured=True):
+    gray_scale_patches, color_patches, coordinates, img_size = img_to_patches(img)
+    var_with_patch = []
+    for i, patch in enumerate(gray_scale_patches):
+        if coloured:
+            var_with_patch.append((get_pixel_var_degree_for_patch(patch), color_patches[i], coordinates[i]))
+        else:
+            var_with_patch.append((get_pixel_var_degree_for_patch(patch), patch, coordinates[i]))
+
+    var_with_patch.sort(reverse=True, key=lambda x: x[0])
+    mid_point = len(var_with_patch) // 2
+    r_patch = [(patch, coor) for var, patch, coor in var_with_patch[:mid_point]]
+    p_patch = [(patch, coor) for var, patch, coor in var_with_patch[mid_point:]]
+    p_patch.reverse()
+    return r_patch, p_patch, img_size
+
+def azimuthalAverage(image, center=None):
+    y, x = np.indices(image.shape)
+    if not center:
+        center = np.array([(x.max() - x.min()) / 2.0, (y.max() - y.min()) / 2.0])
+    r = np.hypot(x - center[0], y - center[1])
+    ind = np.argsort(r.flat)
+    r_sorted = r.flat[ind]
+    i_sorted = image.flat[ind]
+    r_int = r_sorted.astype(int)
+    deltar = r_int[1:] - r_int[:-1]
+    rind = np.where(deltar)[0]
+    nr = rind[1:] - rind[:-1]
+    csim = np.cumsum(i_sorted, dtype=float)
+    tbin = csim[rind[1:]] - csim[rind[:-1]]
+    radial_prof = tbin / nr
+    return radial_prof
+
+def azimuthal_integral(img, epsilon=1e-8, N=50):
+    if len(img.shape) == 3 and img.shape[2] == 3:
+        img = RGB2gray(img)
+    f = np.fft.fft2(img)
+    fshift = np.fft.fftshift(f)
+    fshift += epsilon
+    magnitude_spectrum = 20 * np.log(np.abs(fshift))
+    psd1D = azimuthalAverage(magnitude_spectrum)
+    points = np.linspace(0, N, num=psd1D.size)
+    xi = np.linspace(0, N, num=N)
+    interpolated = griddata(points, psd1D, xi, method='cubic')
+    interpolated = (interpolated - np.min(interpolated)) / (np.max(interpolated) - np.min(interpolated))
+    return interpolated.astype(np.float32)
+
+def positional_emb(coor, im_size, N):
+    img_height, img_width = im_size
+    center_y, center_x = coor
+    normalized_y = center_y / img_height
+    normalized_x = center_x / img_width
+    pos_emb = np.zeros(N)
+    indices = np.arange(N)
+    div_term = 10000 ** (2 * (indices // 2) / N)
+    pos_emb[0::2] = np.sin(normalized_y / div_term[0::2]) + np.sin(normalized_x / div_term[0::2])
+    pos_emb[1::2] = np.cos(normalized_y / div_term[1::2]) + np.cos(normalized_x / div_term[1::2])
+    return pos_emb
+
+def azi_diff(img: PIL.Image.Image, patch_num, N):
+    r, p, im_size = get_rich_poor_patches(img)
+    r_len = len(r)
+    p_len = len(p)
+    patch_emb_r = np.zeros((patch_num, N))
+    patch_emb_p = np.zeros((patch_num, N))
+    positional_emb_r = np.zeros((patch_num, N))
+    positional_emb_p = np.zeros((patch_num, N))
+    coor_r = []
+    coor_p = []
+    if r_len != 0:
+        for idx in range(patch_num):
+            tmp_patch1 = r[idx % r_len][0]
+            tmp_coor1 = r[idx % r_len][1]
+            patch_emb_r[idx] = azimuthal_integral(tmp_patch1, N=N)
+            positional_emb_r[idx] = positional_emb(tmp_coor1, im_size, N)
+            coor_r.append(tmp_coor1)
+    if p_len != 0:
+        for idx in range(patch_num):
+            tmp_patch2 = p[idx % p_len][0]
+            tmp_coor2 = p[idx % p_len][1]
+            patch_emb_p[idx] = azimuthal_integral(tmp_patch2, N=N)
+            positional_emb_p[idx] = positional_emb(tmp_coor2, im_size, N)
+            coor_p.append(tmp_coor2)
+    output = {"total_emb": [patch_emb_r + positional_emb_r / 5, patch_emb_p + positional_emb_p / 5],
+              "positional_emb": [positional_emb_r / 5, positional_emb_p / 5], "coor": [coor_r, coor_p],
+              "image_size": im_size}
+    return output