Delete utils_sr.py

utils_sr.py

@@ -1,141 +0,0 @@
-import numpy as np
-import torch
-from PIL import Image
-import os
-import io
-import imageio
-
-def pad_reflect(image, pad_size):
-    imsize = image.shape
-    height, width = imsize[:2]
-    new_img = np.zeros([height+pad_size*2, width+pad_size*2, imsize[2]]).astype(np.uint8)
-    new_img[pad_size:-pad_size, pad_size:-pad_size, :] = image
-    
-    new_img[0:pad_size, pad_size:-pad_size, :] = np.flip(image[0:pad_size, :, :], axis=0) #top
-    new_img[-pad_size:, pad_size:-pad_size, :] = np.flip(image[-pad_size:, :, :], axis=0) #bottom
-    new_img[:, 0:pad_size, :] = np.flip(new_img[:, pad_size:pad_size*2, :], axis=1) #left
-    new_img[:, -pad_size:, :] = np.flip(new_img[:, -pad_size*2:-pad_size, :], axis=1) #right
-    
-    return new_img
-
-def unpad_image(image, pad_size):
-    return image[pad_size:-pad_size, pad_size:-pad_size, :]
-
-
-def jpegBlur(im,q):
-    buf = io.BytesIO()
-    imageio.imwrite(buf,im,format='jpg',quality=q)
-    s = buf.getbuffer()
-    return imageio.imread(s,format='jpg')
-
-
-def process_array(image_array, expand=True):
-    """ Process a 3-dimensional array into a scaled, 4 dimensional batch of size 1. """
-    
-    image_batch = image_array / 255.0
-    if expand:
-        image_batch = np.expand_dims(image_batch, axis=0)
-    return image_batch
-
-
-def process_output(output_tensor):
-    """ Transforms the 4-dimensional output tensor into a suitable image format. """
-    
-    sr_img = output_tensor.clip(0, 1) * 255
-    sr_img = np.uint8(sr_img)
-    return sr_img
-
-
-def pad_patch(image_patch, padding_size, channel_last=True):
-    """ Pads image_patch with with padding_size edge values. """
-    
-    if channel_last:
-        return np.pad(
-            image_patch,
-            ((padding_size, padding_size), (padding_size, padding_size), (0, 0)),
-            'edge',
-        )
-    else:
-        return np.pad(
-            image_patch,
-            ((0, 0), (padding_size, padding_size), (padding_size, padding_size)),
-            'edge',
-        )
-
-
-def unpad_patches(image_patches, padding_size):
-    return image_patches[:, padding_size:-padding_size, padding_size:-padding_size, :]
-
-
-def split_image_into_overlapping_patches(image_array, patch_size, padding_size=2):
-    """ Splits the image into partially overlapping patches.
-    The patches overlap by padding_size pixels.
-    Pads the image twice:
-        - first to have a size multiple of the patch size,
-        - then to have equal padding at the borders.
-    Args:
-        image_array: numpy array of the input image.
-        patch_size: size of the patches from the original image (without padding).
-        padding_size: size of the overlapping area.
-    """
-    
-    xmax, ymax, _ = image_array.shape
-    x_remainder = xmax % patch_size
-    y_remainder = ymax % patch_size
-    
-    # modulo here is to avoid extending of patch_size instead of 0
-    x_extend = (patch_size - x_remainder) % patch_size
-    y_extend = (patch_size - y_remainder) % patch_size
-    
-    # make sure the image is divisible into regular patches
-    extended_image = np.pad(image_array, ((0, x_extend), (0, y_extend), (0, 0)), 'edge')
-    
-    # add padding around the image to simplify computations
-    padded_image = pad_patch(extended_image, padding_size, channel_last=True)
-    
-    xmax, ymax, _ = padded_image.shape
-    patches = []
-    
-    x_lefts = range(padding_size, xmax - padding_size, patch_size)
-    y_tops = range(padding_size, ymax - padding_size, patch_size)
-    
-    for x in x_lefts:
-        for y in y_tops:
-            x_left = x - padding_size
-            y_top = y - padding_size
-            x_right = x + patch_size + padding_size
-            y_bottom = y + patch_size + padding_size
-            patch = padded_image[x_left:x_right, y_top:y_bottom, :]
-            patches.append(patch)
-    
-    return np.array(patches), padded_image.shape
-
-
-def stich_together(patches, padded_image_shape, target_shape, padding_size=4):
-    """ Reconstruct the image from overlapping patches.
-    After scaling, shapes and padding should be scaled too.
-    Args:
-        patches: patches obtained with split_image_into_overlapping_patches
-        padded_image_shape: shape of the padded image contructed in split_image_into_overlapping_patches
-        target_shape: shape of the final image
-        padding_size: size of the overlapping area.
-    """
-    
-    xmax, ymax, _ = padded_image_shape
-    patches = unpad_patches(patches, padding_size)
-    patch_size = patches.shape[1]
-    n_patches_per_row = ymax // patch_size
-    
-    complete_image = np.zeros((xmax, ymax, 3))
-    
-    row = -1
-    col = 0
-    for i in range(len(patches)):
-        if i % n_patches_per_row == 0:
-            row += 1
-            col = 0
-        complete_image[
-        row * patch_size: (row + 1) * patch_size, col * patch_size: (col + 1) * patch_size,:
-        ] = patches[i]
-        col += 1
-    return complete_image[0: target_shape[0], 0: target_shape[1], :]