ozuvgl

OzUVGL/Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.10
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN pip install numpy scipy
+
+COPY requirements.txt /npr-vgl-ozu/
+WORKDIR /npr-vgl-ozu
+RUN python -m pip install --no-cache-dir -r requirements.txt
+
+COPY . /npr-vgl-ozu
+
+RUN chmod +x run.sh
+CMD ["./run.sh"]

OzUVGL/README.md

@@ -0,0 +1,25 @@
+# VGL OZU - Night Photography Rendering Challenge @ NTIRE 2024, CVPR Workshops
+
+Please put the test data into folder `data/` before building the Docker image.
+
+**IMPORTANT:** Illuminant estimation algorithm contains random subsampling steps, to reproduce the 3rd validation outputs exactly, please do not forget to include "*_wb.json" files in submitted outputs folder to the corresponding data folder.
+
+To build the Docker image:
+
+```
+docker build -t npr-vgl-ozu .
+```
+
+You may run the process as follows:
+
+```
+docker run -v $(pwd)/results:/npr-vgl-ozu/results npr-vgl-ozu
+```
+
+Results will be placed at `./results`
+
+To cite the challenge report:
+
+```
+TBD
+```

OzUVGL/ips/__init__.py

@@ -0,0 +1,27 @@
+from ips.ops import *
+
+
+def process(raw_image, metadata):
+    out = normalize(raw_image, metadata["black_level"], metadata["white_level"])
+    out = demosaic(out, metadata["cfa_pattern"])
+    out = raw_color_denoise(out, metadata["noise_profile"][1])
+    out = white_balance(out, metadata)
+    color_matrix = [  # average color transformation matrix of Huawei Mate 40 Pro
+        1.06835938, -0.29882812, -0.14257812, 
+        -0.43164062,  1.35546875,  0.05078125, 
+        -0.1015625,   0.24414062,  0.5859375
+    ]
+    out = xyz_transform(out, color_matrix)
+    out = xyz_to_srgb(out)
+    out = luminance_denoise(out, metadata["tv_weight"])
+    out = perform_tone_mapping(out, metadata)
+    out = global_mean_contrast(out, metadata["global_mc_beta"])
+    out = s_curve_correction(out, metadata["scc_alpha"], metadata["scc_lambda"])
+    out = histogram_stretching(out)
+    out = memory_color_enhancement(out)
+    out = unsharp_masking(out)
+    out = to_uint8(out)
+    out = resize(out, metadata["exp_width"], metadata["exp_height"])  # None means direct return the image, change the params to (w, h) if downsampling required.
+    out = fix_orientation(out, metadata["orientation"])
+
+    return out

OzUVGL/ips/ops.py

@@ -0,0 +1,418 @@
+import cv2
+import numpy as np
+
+from fractions import Fraction
+from exifread.utils import Ratio
+from PIL import Image
+from skimage.color import rgb2hsv, hsv2rgb
+from skimage.exposure import rescale_intensity
+from skimage.filters import gaussian as sk_gaussian
+from skimage.restoration import denoise_tv_bregman
+from scipy import signal
+
+from colour_demosaicing import demosaicing_CFA_Bayer_Menon2007
+
+from utils.misc import *
+from utils.color import *
+from ips.wb import illumination_parameters_estimation
+
+
+def normalize(raw_image, black_level, white_level):
+    if isinstance(black_level, list) and len(black_level) == 1:
+        black_level = float(black_level[0])
+    if isinstance(white_level, list) and len(white_level) == 1:
+        white_level = float(white_level[0])
+    black_level_mask = black_level
+    if type(black_level) is list and len(black_level) == 4:
+        if type(black_level[0]) is Ratio:
+            black_level = ratios2floats(black_level)
+        if type(black_level[0]) is Fraction:
+            black_level = fractions2floats(black_level)
+        black_level_mask = np.zeros(raw_image.shape)
+        idx2by2 = [[0, 0], [0, 1], [1, 0], [1, 1]]
+        step2 = 2
+        for i, idx in enumerate(idx2by2):
+            black_level_mask[idx[0]::step2, idx[1]::step2] = black_level[i]
+    normalized_image = raw_image.astype(np.float32) - black_level_mask
+    # if some values were smaller than black level
+    normalized_image[normalized_image < 0] = 0
+    normalized_image = normalized_image / (white_level - black_level_mask)
+    return normalized_image
+
+
+def demosaic(norm_image, cfa_pattern):
+    return demosaicing_CFA_Bayer_Menon2007(norm_image, decode_cfa_pattern(cfa_pattern))
+
+
+def denoise(demosaiced_image, y_noise_profile, cc_noise_profile):
+    ycc_demosaiced = rgb2ycc(demosaiced_image[:, :, ::-1])
+    y_demosaiced = ycc_demosaiced[:, :, 0]
+    cc_demosaiced = ycc_demosaiced[:, :, 1:]
+    current_image_y = y_demosaiced
+    current_image_cc = gaussian(cc_demosaiced, sigma=cc_noise_profile)
+    current_image_ycc = np.concatenate([
+        np.expand_dims(current_image_y, -1), 
+        current_image_cc
+    ], axis=-1)
+    return ycc2rgb(current_image_ycc)[:, :, ::-1]
+
+
+def raw_color_denoise(demosaiced_image, cc_noise_profile):
+    ycc_demosaiced = rgb2ycc(demosaiced_image[:, :, ::-1])
+    cc_demosaiced = ycc_demosaiced[:, :, 1:]
+    cc_demosaiced_denoised = sk_gaussian(cc_demosaiced, sigma=cc_noise_profile)
+    ycc_demosaiced[:, :, 1:] = cc_demosaiced_denoised
+    return ycc2rgb(ycc_demosaiced)[:, :, ::-1]
+
+
+def luminance_denoise(tone_mapped_image, weight=20.0):
+    ycc_tone_mapped = rgb2ycc(tone_mapped_image[:, :, ::-1])
+    y_tone_mapped = ycc_tone_mapped[:, :, 0]
+    y_tone_mapped_denoised = denoise_tv_bregman(y_tone_mapped, weight=weight)
+    ycc_tone_mapped[:, :, 0] = np.clip(y_tone_mapped_denoised, 1e-4, 0.999)
+    return ycc2rgb(ycc_tone_mapped)[:, :, ::-1]
+
+
+def white_balance(denoised_image, metadata, max_repeat_limit=10000):
+    if metadata["wb_estimation"] is not None:
+        as_shot_neutral = np.array(metadata["wb_estimation"])
+        white_balanced_image = np.dot(denoised_image, as_shot_neutral.T)
+        return np.clip(white_balanced_image, 0.0, 1.0)
+    illumuniation_estimation_algorithm = metadata["wb_method"]
+    as_shot_neutral = illumination_parameters_estimation(denoised_image, illumuniation_estimation_algorithm)    
+    
+    if isinstance(as_shot_neutral[0], Ratio):
+        as_shot_neutral = ratios2floats(as_shot_neutral)
+
+    as_shot_neutral = np.asarray(as_shot_neutral)
+    # transform vector into matrix
+    if as_shot_neutral.shape == (3,):
+        as_shot_neutral = np.diag(1./as_shot_neutral)
+
+    assert as_shot_neutral.shape == (3, 3)
+    repeat_count = 0
+    while (as_shot_neutral[0, 0] < 2.3 and as_shot_neutral[2, 2] < 2.3) or (as_shot_neutral[0, 0] < 2.02 or as_shot_neutral[2, 2] < 1.92):
+        if repeat_count < max_repeat_limit:
+            as_shot_neutral = illumination_parameters_estimation(denoised_image, illumuniation_estimation_algorithm)
+            if isinstance(as_shot_neutral[0], Ratio):
+                as_shot_neutral = ratios2floats(as_shot_neutral)
+
+            as_shot_neutral = np.asarray(as_shot_neutral)
+            # transform vector into matrix
+            if as_shot_neutral.shape == (3,):
+                as_shot_neutral = np.diag(1./as_shot_neutral)
+
+            assert as_shot_neutral.shape == (3, 3)
+        else:
+            print(f"WARNING! Invalid range for illumination matrix and repeated to estimate by '{illumuniation_estimation_algorithm}' so many times. Using 'gw' for illumination estimation now...")
+            as_shot_neutral = illumination_parameters_estimation(denoised_image, "gw")  
+            if isinstance(as_shot_neutral[0], Ratio):
+                as_shot_neutral = ratios2floats(as_shot_neutral)
+
+            as_shot_neutral = np.asarray(as_shot_neutral)
+            # transform vector into matrix
+            if as_shot_neutral.shape == (3,):
+                as_shot_neutral = np.diag(1./as_shot_neutral)
+
+            assert as_shot_neutral.shape == (3, 3)
+            break
+        repeat_count += 1
+    
+    white_balanced_image = np.dot(denoised_image, as_shot_neutral.T)
+    metadata["wb_estimation"] = as_shot_neutral.tolist()
+
+    # print(as_shot_neutral)
+    return np.clip(white_balanced_image, 0.0, 1.0)
+
+
+def xyz_transform(wb_image, color_matrix):
+    if isinstance(color_matrix[0], Fraction):
+        color_matrix = fractions2floats(color_matrix)
+    xyz2cam = np.reshape(np.asarray(color_matrix), (3, 3))
+    # normalize rows (needed?)
+    xyz2cam = xyz2cam / np.sum(xyz2cam, axis=1, keepdims=True)
+    # inverse
+    cam2xyz = np.linalg.inv(xyz2cam)
+    # for now, use one matrix  # TODO: interpolate btween both
+    # simplified matrix multiplication
+    xyz_image = cam2xyz[np.newaxis, np.newaxis, :, :] * wb_image[:, :, np.newaxis, :]
+    xyz_image = np.sum(xyz_image, axis=-1)
+    xyz_image = np.clip(xyz_image, 0.0, 1.0)
+    return xyz_image
+
+
+def xyz_to_srgb(xyz_image):
+    # srgb2xyz = np.array([[0.4124564, 0.3575761, 0.1804375],
+    #                      [0.2126729, 0.7151522, 0.0721750],
+    #                      [0.0193339, 0.1191920, 0.9503041]])
+
+    # xyz2srgb = np.linalg.inv(srgb2xyz)
+
+    xyz2srgb = np.array([[3.2404542, -1.5371385, -0.4985314],
+                         [-0.9692660, 1.8760108, 0.0415560],
+                         [0.0556434, -0.2040259, 1.0572252]])
+
+    # normalize rows (needed?)
+    xyz2srgb = xyz2srgb / np.sum(xyz2srgb, axis=-1, keepdims=True)
+
+    srgb_image = xyz2srgb[np.newaxis, np.newaxis,
+                          :, :] * xyz_image[:, :, np.newaxis, :]
+    srgb_image = np.sum(srgb_image, axis=-1)
+    srgb_image = np.clip(srgb_image, 0.0, 1.0)
+    return srgb_image
+
+
+def apply_tmo_flash(Y, a):
+    Y[Y == 0] = 1e-9
+    return Y / (Y + a * np.exp(np.mean(np.log(Y))))
+
+
+def apply_tmo_storm(Y, a, kernels):
+    rows, cols = Y.shape
+    Y[Y == 0] = 1e-9
+    return sum([
+        Y / (Y + a * np.exp(cv2.boxFilter(np.log(Y), -1, (int(min(rows // kernel, cols // kernel)),) * 2)))
+        for kernel in kernels
+    ]) / len(kernels)
+
+
+def apply_tmo_nite(Y, CC, kernels):
+    rows, cols = Y.shape
+    Y[Y == 0] = 1e-9
+    y_mu, y_std = max(Y.mean(), 0.001), Y.std()
+    cc_std = CC.std()
+    # tmo_offset = np.exp(y_mu * (cc_std / y_std) * 100)
+    tmo_offset = 10. / np.sqrt(np.exp(np.log(y_mu) * (np.log(cc_std) / np.log(y_std))) * 100)
+    # print(f"Y mean: {y_mu:.3f}, Y std: {y_std:.3f}, CC std: {cc_std:.3f}, Offset: {tmo_offset:.3f}")
+
+    # tmo_scale = 8.5 + min(6.5, round(tmo_offset))
+    tmo_scale = min(28., max(5., tmo_offset))
+    # print(f"TMO scale: {tmo_scale}")
+    return sum([
+        Y / np.clip((Y + tmo_scale * np.exp(cv2.boxFilter(np.log(Y), -1, (int(min(rows // kernel, cols // kernel)),) * 2))), 0., 1.)
+        for kernel in kernels
+    ]) / len(kernels)
+
+
+def perform_tone_mapping(source, metadata):
+    ycc_source = rgb2ycc(source[:, :, ::-1])
+    y_source = ycc_source[:, :, 0]
+    cc_source = ycc_source[:, :, 1:]
+
+    if metadata["tmo_type"].lower() == "flash":
+        y_hat_source = apply_tmo_flash(y_source, metadata["tmo_scale"])
+    elif metadata["tmo_type"].lower() == "storm":
+        y_hat_source = apply_tmo_storm(y_source, metadata["tmo_scale"], metadata["tmo_kernels"])
+    else:  # nite
+        y_hat_source = apply_tmo_nite(y_source, cc_source, metadata["tmo_kernels"])
+
+    ycc_nite = np.concatenate([
+        np.expand_dims(y_hat_source, -1), 
+        cc_source
+    ], axis=-1)
+    result = ycc2rgb(ycc_nite)[:, :, ::-1]
+    if metadata["tmo_do_leap"]:
+        target_mean_grayscale = 0.282  # 72 / 255
+        result = np.clip(result, a_min=0., a_max=1.)
+        grayscale = cv2.cvtColor(result * 255., cv2.COLOR_BGR2GRAY) / 255.
+        result *= target_mean_grayscale / np.mean(grayscale)
+    result = np.clip(result, a_min=0., a_max=1.)
+    return result
+
+
+def global_mean_contrast(input_im, beta=1.0):
+    mu_ = input_im.mean(axis=(0, 1), keepdims=True)
+    output_im = mu_ + beta * (input_im - mu_)
+    output_im = np.where(0 > output_im, input_im, output_im)
+    output_im = np.where(1 < output_im, input_im, output_im)
+    return output_im
+
+
+def s_curve_correction(input_im, alpha=0.5, lambd=0.5):
+    ycc_ = rgb2ycc(input_im[:, :, ::-1])
+    Y = ycc_[:, :, 0]
+    Y_hat = alpha + np.where(
+        Y >= alpha, 
+        (1 - alpha) * np.power(((Y - alpha) / (1 - alpha)), lambd), 
+        -alpha * np.power((1 - (Y / alpha)), lambd)
+    )
+    ycc_[:, :, 0] = Y_hat
+    bgr_ = np.clip(ycc2rgb(ycc_)[:, :, ::-1], a_min=0., a_max=1.)
+    return bgr_
+
+
+def histogram_stretching(input_im):
+    hsv = rgb2hsv(input_im[:, :, ::-1])
+    V = hsv[:, :, 0]
+    p0_01, p99 = np.percentile(V, (0.01, 99.99))
+    if 0.7 > p99:
+         _, p99 = np.percentile(V, (0.01, 99.5))
+
+    V_hat = rescale_intensity(V, in_range=(p0_01, p99))
+    hsv[:, :, 0] = V_hat
+    bgr_ = np.clip(hsv2rgb(hsv), a_min=0., a_max=1.)[:, :, ::-1]
+    return bgr_
+
+
+def conditional_contrast_correction(input_im, threshold=0.5):
+    ycc_ = rgb2ycc(input_im[:, :, ::-1])
+    Y = ycc_[:, :, 0]
+    y_avg = Y.mean()
+    if y_avg > threshold:
+        Y_hat = Y.copy()
+        idx = Y_hat <= 0.0031308
+        Y_hat[idx] *= 12.92
+        Y_hat[idx == False] = (Y_hat[idx == False] ** (1.0 / 2.4)) * 1.055 - 0.055
+    else:
+        alpha = 0.5
+        lambd = 1.2
+        Y_hat = alpha + np.where(
+            Y >= alpha, 
+            (1 - alpha) * np.power(((Y - alpha) / (1 - alpha)), lambd), 
+            -alpha * np.power((1 - (Y / alpha)), lambd)
+        )
+    ycc_[:, :, 0] = Y_hat
+    bgr_ = np.clip(ycc2rgb(ycc_)[:, :, ::-1], a_min=0., a_max=1.)
+    return bgr_
+
+
+def memory_color_enhancement(data, color_space="srgb", illuminant="D65", clip_range=[0, 1], cie_version="1964"):
+    target_hue = [30., -125., 100.]
+    hue_preference = [20., -118., 130.]
+    hue_sigma = [20., 10., 5.]
+    is_both_side = [True, False, False]
+    multiplier = [0.6, 0.6, 0.6]
+    chroma_preference = [25., 14., 30.]
+    chroma_sigma = [10., 10., 5.]
+
+    # RGB to xyz
+    data = rgb2xyz(data, color_space, clip_range)
+    # xyz to lab
+    data = xyz2lab(data, cie_version, illuminant)
+    # lab to lch
+    data = lab2lch(data)
+
+    # hue squeezing
+    # we are traversing through different color preferences
+    height, width, _ = data.shape
+    hue_correction = np.zeros((height, width), dtype=np.float32)
+    for i in range(0, np.size(target_hue)):
+
+        delta_hue = data[:, :, 2] - hue_preference[i]
+
+        if is_both_side[i]:
+            weight_temp = np.exp(-np.power(data[:, :, 2] - target_hue[i], 2) / (2 * hue_sigma[i] ** 2)) + \
+                          np.exp(-np.power(data[:, :, 2] + target_hue[i], 2) / (2 * hue_sigma[i] ** 2))
+        else:
+            weight_temp = np.exp(-np.power(data[:, :, 2] - target_hue[i], 2) / (2 * hue_sigma[i] ** 2))
+
+        weight_hue = multiplier[i] * weight_temp / np.max(weight_temp)
+
+        weight_chroma = np.exp(-np.power(data[:, :, 1] - chroma_preference[i], 2) / (2 * chroma_sigma[i] ** 2))
+
+        hue_correction = hue_correction + np.multiply(np.multiply(delta_hue, weight_hue), weight_chroma)
+
+    # correct the hue
+    data[:, :, 2] = data[:, :, 2] - hue_correction
+
+    # lch to lab
+    data = lch2lab(data)
+    # lab to xyz
+    data = lab2xyz(data, cie_version, illuminant)
+    # xyz to rgb
+    data = xyz2rgb(data, color_space, clip_range)
+
+    data = outOfGamutClipping(data, range=clip_range[1])
+    return data
+
+
+def unsharp_masking(data, gaussian_kernel_size=[5, 5], gaussian_sigma=2.0, slope=1.5, tau_threshold=0.05, gamma_speed=4., clip_range=[0, 1]):
+    # create gaussian kernel
+    gaussian_kernel = gaussian(gaussian_kernel_size, gaussian_sigma)
+
+    # convolve the image with the gaussian kernel
+    # first input is the image
+    # second input is the kernel
+    # output shape will be the same as the first input
+    # boundary will be padded by using symmetrical method while convolving
+    if np.ndim(data) > 2:
+        image_blur = np.empty(np.shape(data), dtype=np.float32)
+        for i in range(0, np.shape(data)[2]):
+            image_blur[:, :, i] = signal.convolve2d(data[:, :, i], gaussian_kernel, mode="same", boundary="symm")
+    else:
+        image_blur = signal.convolve2d(data, gaussian_kernel, mode="same", boundary="symm")
+
+    # the high frequency component image
+    image_high_pass = data - image_blur
+
+    # soft coring (see in utility)
+    # basically pass the high pass image via a slightly nonlinear function
+    tau_threshold = tau_threshold * clip_range[1]
+
+    # add the soft cored high pass image to the original and clip
+    # within range and return
+    def soft_coring(img_hp, slope, tau_threshold, gamma_speed):
+        return slope * np.float32(img_hp) * (1. - np.exp(-((np.abs(img_hp / tau_threshold))**gamma_speed)))
+    return np.clip(data + soft_coring(image_high_pass, slope, tau_threshold, gamma_speed), clip_range[0], clip_range[1])
+
+
+def to_uint8(srgb):
+    return (srgb * 255).astype(np.uint8)
+
+
+def resize(img, width=None, height=None):
+    if width is None or height is None:
+        return img
+    img_pil = Image.fromarray(img)
+    out_size = (width, height)
+    if img_pil.size == out_size:
+        return img
+    out_img = img_pil.resize(out_size, Image.Resampling.LANCZOS)
+    out_img = np.array(out_img)
+    return out_img
+
+
+def fix_orientation(image, orientation):
+    # 1 = Horizontal (normal)
+    # 2 = Mirror horizontal
+    # 3 = Rotate 180
+    # 4 = Mirror vertical
+    # 5 = Mirror horizontal and rotate 270 CW
+    # 6 = Rotate 90 CW
+    # 7 = Mirror horizontal and rotate 90 CW
+    # 8 = Rotate 270 CW
+
+    orientation_dict = {
+        "Horizontal (normal)": 1,
+        "Mirror horizontal": 2,
+        "Rotate 180": 3,
+        "Mirror vertical": 4,
+        "Mirror horizontal and rotate 270 CW": 5,
+        "Rotate 90 CW": 6,
+        "Mirror horizontal and rotate 90 CW": 7,
+        "Rotate 270 CW": 8
+    }
+
+    if type(orientation) is list:
+        orientation = orientation[0]
+    orientation = orientation_dict[orientation]
+    if orientation == 1:
+        pass
+    elif orientation == 2:
+        image = cv2.flip(image, 0)
+    elif orientation == 3:
+        image = cv2.rotate(image, cv2.ROTATE_180)
+    elif orientation == 4:
+        image = cv2.flip(image, 1)
+    elif orientation == 5:
+        image = cv2.flip(image, 0)
+        image = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+    elif orientation == 6:
+        image = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
+    elif orientation == 7:
+        image = cv2.flip(image, 0)
+        image = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
+    elif orientation == 8:
+        image = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+
+    return image

OzUVGL/ips/wb.py

@@ -0,0 +1,40 @@
+import numpy as np
+from utils.color import rgb2ycc
+
+def illumination_parameters_estimation(current_image, illumination_estimation_option):
+    ie_method = illumination_estimation_option.lower()
+
+    if ie_method == "gw":
+        ie = np.mean(current_image, axis=(0, 1))
+        ie /= ie[1]
+        return ie
+    elif ie_method == "sog":
+        sog_p = 4.
+        ie = np.mean(current_image**sog_p, axis=(0, 1))**(1/sog_p)
+        ie /= ie[1]
+        return ie
+    elif ie_method == "wp":
+        ie = np.max(current_image, axis=(0, 1))
+        ie /= ie[1]
+        return ie
+    elif ie_method == "iwp":
+        samples_count = 10
+        sample_size = 10
+        rows, cols = current_image.shape[:2]
+        data = np.reshape(current_image, (rows*cols, 3))
+        maxima = np.zeros((samples_count, 3))
+        for i in range(samples_count):
+            maxima[i, :] = np.max(data[np.random.randint(low=0, high=rows*cols, size=(sample_size)), :], axis=0)
+        ie = np.mean(maxima, axis=0)
+        ie /= ie[1]
+        return ie
+    else:
+        raise ValueError(
+            'Bad illumination_estimation_option value! Use the following options: "gw", "wp", "sog", "iwp"')
+      
+      
+def ratios2floats(ratios):
+    floats = []
+    for ratio in ratios:
+        floats.append(float(ratio.num) / ratio.den)
+    return floats

OzUVGL/main.py

@@ -0,0 +1,93 @@
+import os
+import time
+import random
+import glog as log
+import numpy as np
+from typing import List
+
+from utils.io import read_image, write_processed_as_jpg, write_illuminant_estimation
+import ips
+
+expected_landscape_img_height = 768  # 6144
+expected_landscape_img_width = 1024  # 8192
+
+
+# Flash TMO works better with a=20 and Leap_35 for night images.
+# Storm TMO tends to have higher a value than the default one. Leap is must. 
+# Not stable for different illuminant settings, so the scale parameter should be adaptive to something.
+# Luma and Color statistics could be the best option we have to make it adaptive.
+# Higher number of kernels higher details visible in local areas, however too large numbers produces flares or makes it unrealistic.
+def single_run(
+    base_dir: str,
+    img_names: List,
+    out_dir: str,
+    wb_method: str = "iwp",
+    tmo_type: str = "nite",
+    tv_weight: int = 20
+):
+    log.info(
+        "Parameters:\n"
+        f"WB Method: {wb_method}\n"
+        f"TMO Type: {tmo_type}\n"
+        f"Luma TV weight : {tv_weight}\n"
+    )
+    os.makedirs("./" + out_dir, exist_ok=True)
+    # random.shuffle(img_names)
+    infer_times = list()
+
+    for i, img_name in enumerate(img_names):
+        p = round(100 * (i+1) / len(img_names), 2)
+        log.info(f"({p:.2f}%) Processing {i+1} of {len(img_names)} images, image name: {img_name}")
+        path = os.path.join(base_dir, img_name)
+        assert os.path.exists(path)
+
+        raw_image, metadata = read_image(path)
+        save_ill_est = metadata["wb_estimation"] is None
+        metadata["exp_height"] = expected_landscape_img_height
+        metadata["exp_width"] = expected_landscape_img_width
+        metadata["wb_method"] = wb_method
+        metadata["tv_weight"] = tv_weight
+        metadata["tmo_type"] = tmo_type
+        if tmo_type.lower() in ["flash", "storm"]:
+            metadata["tmo_scale"] = 10  # 20 can be also used, 10 better for some images, but 20 for some others depending on the variety of the illuminant source.
+        if tmo_type.lower() in ["storm", "nite"]:
+            metadata["tmo_kernels"] = (1, 2, 4, 8, 16, 32)  # more than 16, produce flares in dark regions in the case of occlusion.
+        metadata["tmo_do_leap"] = True  # Leap is must for Flash, Storm and Nite.
+        metadata["global_mc_beta"] = 1.2
+        metadata["scc_alpha"] = 0.5
+        metadata["scc_lambda"] = 0.9
+        
+        out_path = os.path.join(out_dir, img_name.replace("png", "jpg"))
+        if os.path.exists(out_path):
+            continue
+        start_time = time.time()
+        out = ips.process(raw_image=raw_image, metadata=metadata)
+        end_time = time.time()
+        infer_times.append(end_time - start_time)
+
+        if save_ill_est:
+            ill_est_path = os.path.join(out_dir, img_name.replace(".png", "_wb.json"))
+            write_illuminant_estimation(metadata["wb_estimation"], ill_est_path)
+        write_processed_as_jpg(out, out_path)
+    print(f"Average inference time: {np.mean(infer_times)} seconds")
+
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description='Night Photography Rendering Challenge - Team VGL OzU')
+    parser.add_argument('-d', '--data_dir', type=str, default="data/", help="data directory")
+    parser.add_argument('-o', '--output_dir', type=str, default="results/", help="output directory")
+    parser.add_argument('-s', '--submission_name', type=str, default="vgl-ozu", help='submission name')
+    args = parser.parse_args()
+
+    data_dir = args.data_dir
+    if not os.path.exists(data_dir) or len(os.listdir(data_dir)) == 0:
+        log.info(f"Data does not exist, please put the data from given link into '{data_dir}'...")
+        os.makedirs(data_dir, exist_ok=True)
+        log.info("After this, please re-run.")
+    else:
+        base_dir = args.data_dir
+        out_dir = args.output_dir
+        img_names = os.listdir(base_dir)
+        img_names = [img_name for img_name in img_names if ".png" in img_name]
+        single_run(base_dir, img_names, out_dir)

OzUVGL/requirements.txt

@@ -0,0 +1,10 @@
+colour_demosaicing==0.2.5
+ExifRead==3.0.0
+glog==0.3.1
+numpy==1.24.3
+opencv_contrib_python==4.7.0.72
+Pillow==10.2.0
+requests==2.31.0
+scikit_image==0.19.3
+scipy==1.12.0
+scikit-image

OzUVGL/run.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+python3 main.py

OzUVGL/utils/color.py

@@ -0,0 +1,306 @@
+import numpy as np
+
+
+def rgb2gray(data):
+    return 0.299 * data[:, :, 0] + \
+           0.587 * data[:, :, 1] + \
+           0.114 * data[:, :, 2]
+
+
+def rgb2ycc(data, rule="bt601"):
+    # map to select kr and kb
+    kr_kb_dict = {"bt601": [0.299, 0.114],
+                  "bt709": [0.2126, 0.0722],
+                  "bt2020": [0.2627, 0.0593]}
+
+    kr = kr_kb_dict[rule][0]
+    kb = kr_kb_dict[rule][1]
+    kg = 1 - (kr + kb)
+
+    output = np.empty(np.shape(data), dtype=np.float32)
+    output[:, :, 0] = kr * data[:, :, 0] + \
+                      kg * data[:, :, 1] + \
+                      kb * data[:, :, 2]
+    output[:, :, 1] = 0.5 * ((data[:, :, 2] - output[:, :, 0]) / (1 - kb))
+    output[:, :, 2] = 0.5 * ((data[:, :, 0] - output[:, :, 0]) / (1 - kr))
+
+    return output
+
+
+def ycc2rgb(data, rule="bt601"):
+    # map to select kr and kb
+    kr_kb_dict = {"bt601": [0.299, 0.114],
+                  "bt709": [0.2126, 0.0722],
+                  "bt2020": [0.2627, 0.0593]}
+
+    kr = kr_kb_dict[rule][0]
+    kb = kr_kb_dict[rule][1]
+    kg = 1 - (kr + kb)
+
+    output = np.empty(np.shape(data), dtype=np.float32)
+    output[:, :, 0] = 2. * data[:, :, 2] * (1 - kr) + data[:, :, 0]
+    output[:, :, 2] = 2. * data[:, :, 1] * (1 - kb) + data[:, :, 0]
+    output[:, :, 1] = (data[:, :, 0] - kr * output[:, :, 0] - kb * output[:, :, 2]) / kg
+
+    return output
+
+
+def degamma_srgb(data, clip_range=[0, 65535]):
+    # bring data in range 0 to 1
+    data = np.clip(data, clip_range[0], clip_range[1])
+    data = np.divide(data, clip_range[1])
+
+    data = np.asarray(data)
+    mask = data > 0.04045
+
+    # basically, if data[x, y, c] > 0.04045, data[x, y, c] = ( (data[x, y, c] + 0.055) / 1.055 ) ^ 2.4
+    #            else, data[x, y, c] = data[x, y, c] / 12.92
+    data[mask] += 0.055
+    data[mask] /= 1.055
+    data[mask] **= 2.4
+
+    data[np.invert(mask)] /= 12.92
+
+    # rescale
+    return np.clip(data * clip_range[1], clip_range[0], clip_range[1])
+
+
+def degamma_adobe_rgb_1998(data, clip_range=[0, 65535]):
+    # bring data in range 0 to 1
+    data = np.clip(data, clip_range[0], clip_range[1])
+    data = np.divide(data, clip_range[1])
+
+    data = np.power(data, 2.2)  # originally raised to 2.19921875
+
+    # rescale
+    return np.clip(data * clip_range[1], clip_range[0], clip_range[1])
+
+
+def rgb2xyz(data, color_space="srgb", clip_range=[0, 255]):
+    # input rgb in range clip_range
+    # output xyz is in range 0 to 1
+    if color_space == "srgb":
+        # degamma / linearization
+        data = degamma_srgb(data, clip_range)
+        data = np.float32(data)
+        data = np.divide(data, clip_range[1])
+
+        # matrix multiplication`
+        output = np.empty(np.shape(data), dtype=np.float32)
+        output[:, :, 0] = data[:, :, 0] * 0.4124 + data[:, :, 1] * 0.3576 + data[:, :, 2] * 0.1805
+        output[:, :, 1] = data[:, :, 0] * 0.2126 + data[:, :, 1] * 0.7152 + data[:, :, 2] * 0.0722
+        output[:, :, 2] = data[:, :, 0] * 0.0193 + data[:, :, 1] * 0.1192 + data[:, :, 2] * 0.9505
+    elif color_space == "adobe-rgb-1998":
+        # degamma / linearization
+        data = degamma_adobe_rgb_1998(data, clip_range)
+        data = np.float32(data)
+        data = np.divide(data, clip_range[1])
+
+        # matrix multiplication
+        output = np.empty(np.shape(data), dtype=np.float32)
+        output[:, :, 0] = data[:, :, 0] * 0.5767309 + data[:, :, 1] * 0.1855540 + data[:, :, 2] * 0.1881852
+        output[:, :, 1] = data[:, :, 0] * 0.2973769 + data[:, :, 1] * 0.6273491 + data[:, :, 2] * 0.0752741
+        output[:, :, 2] = data[:, :, 0] * 0.0270343 + data[:, :, 1] * 0.0706872 + data[:, :, 2] * 0.9911085
+    elif color_space == "linear":
+        # matrix multiplication`
+        output = np.empty(np.shape(data), dtype=np.float32)
+        data = np.float32(data)
+        data = np.divide(data, clip_range[1])
+        output[:, :, 0] = data[:, :, 0] * 0.4124 + data[:, :, 1] * 0.3576 + data[:, :, 2] * 0.1805
+        output[:, :, 1] = data[:, :, 0] * 0.2126 + data[:, :, 1] * 0.7152 + data[:, :, 2] * 0.0722
+        output[:, :, 2] = data[:, :, 0] * 0.0193 + data[:, :, 1] * 0.1192 + data[:, :, 2] * 0.9505
+    else:
+        print("Warning! color_space must be srgb or adobe-rgb-1998.")
+        return
+
+    return output
+
+
+def gamma_srgb(data, clip_range=[0, 65535]):
+    # bring data in range 0 to 1
+    data = np.clip(data, clip_range[0], clip_range[1])
+    data = np.divide(data, clip_range[1])
+
+    data = np.asarray(data)
+    mask = data > 0.0031308
+
+    # basically, if data[x, y, c] > 0.0031308, data[x, y, c] = 1.055 * ( var_R(i, j) ^ ( 1 / 2.4 ) ) - 0.055
+    #            else, data[x, y, c] = data[x, y, c] * 12.92
+    data[mask] **= 0.4167
+    data[mask] *= 1.055
+    data[mask] -= 0.055
+
+    data[np.invert(mask)] *= 12.92
+
+    # rescale
+    return np.clip(data * clip_range[1], clip_range[0], clip_range[1])
+
+
+def gamma_adobe_rgb_1998(data, clip_range=[0, 65535]):
+    # bring data in range 0 to 1
+    data = np.clip(data, clip_range[0], clip_range[1])
+    data = np.divide(data, clip_range[1])
+
+    data = np.power(data, 0.4545)
+
+    # rescale
+    return np.clip(data * clip_range[1], clip_range[0], clip_range[1])
+
+
+def xyz2rgb(data, color_space="srgb", clip_range=[0, 255]):
+    # input xyz is in range 0 to 1
+    # output rgb in clip_range
+
+    # allocate space for output
+    output = np.empty(np.shape(data), dtype=np.float32)
+
+    if color_space == "srgb":
+        # matrix multiplication
+        output[:, :, 0] = data[:, :, 0] * 3.2406 + data[:, :, 1] * -1.5372 + data[:, :, 2] * -0.4986
+        output[:, :, 1] = data[:, :, 0] * -0.9689 + data[:, :, 1] * 1.8758 + data[:, :, 2] * 0.0415
+        output[:, :, 2] = data[:, :, 0] * 0.0557 + data[:, :, 1] * -0.2040 + data[:, :, 2] * 1.0570
+
+        # gamma to retain nonlinearity
+        output = gamma_srgb(output * clip_range[1], clip_range)
+    elif color_space == "adobe-rgb-1998":
+        # matrix multiplication
+        output[:, :, 0] = data[:, :, 0] * 2.0413690 + data[:, :, 1] * -0.5649464 + data[:, :, 2] * -0.3446944
+        output[:, :, 1] = data[:, :, 0] * -0.9692660 + data[:, :, 1] * 1.8760108 + data[:, :, 2] * 0.0415560
+        output[:, :, 2] = data[:, :, 0] * 0.0134474 + data[:, :, 1] * -0.1183897 + data[:, :, 2] * 1.0154096
+
+        # gamma to retain nonlinearity
+        output = gamma_adobe_rgb_1998(output * clip_range[1], clip_range)
+    elif color_space == "linear":
+
+        # matrix multiplication
+        output[:, :, 0] = data[:, :, 0] * 3.2406 + data[:, :, 1] * -1.5372 + data[:, :, 2] * -0.4986
+        output[:, :, 1] = data[:, :, 0] * -0.9689 + data[:, :, 1] * 1.8758 + data[:, :, 2] * 0.0415
+        output[:, :, 2] = data[:, :, 0] * 0.0557 + data[:, :, 1] * -0.2040 + data[:, :, 2] * 1.0570
+
+        # gamma to retain nonlinearity
+        output = output * clip_range[1]
+    else:
+        print("Warning! color_space must be srgb or adobe-rgb-1998.")
+        return
+
+    return output
+
+
+def get_xyz_reference(cie_version="1931", illuminant="d65"):
+    if cie_version == "1931":
+        xyz_reference_dictionary = {"A": [109.850, 100.0, 35.585],
+                                    "B": [99.0927, 100.0, 85.313],
+                                    "C": [98.074, 100.0, 118.232],
+                                    "d50": [96.422, 100.0, 82.521],
+                                    "d55": [95.682, 100.0, 92.149],
+                                    "d65": [95.047, 100.0, 108.883],
+                                    "d75": [94.972, 100.0, 122.638],
+                                    "E": [100.0, 100.0, 100.0],
+                                    "F1": [92.834, 100.0, 103.665],
+                                    "F2": [99.187, 100.0, 67.395],
+                                    "F3": [103.754, 100.0, 49.861],
+                                    "F4": [109.147, 100.0, 38.813],
+                                    "F5": [90.872, 100.0, 98.723],
+                                    "F6": [97.309, 100.0, 60.191],
+                                    "F7": [95.044, 100.0, 108.755],
+                                    "F8": [96.413, 100.0, 82.333],
+                                    "F9": [100.365, 100.0, 67.868],
+                                    "F10": [96.174, 100.0, 81.712],
+                                    "F11": [100.966, 100.0, 64.370],
+                                    "F12": [108.046, 100.0, 39.228]}
+    elif cie_version == "1964":
+        xyz_reference_dictionary = {"A": [111.144, 100.0, 35.200],
+                                    "B": [99.178, 100.0, 84.3493],
+                                    "C": [97.285, 100.0, 116.145],
+                                    "D50": [96.720, 100.0, 81.427],
+                                    "D55": [95.799, 100.0, 90.926],
+                                    "D65": [94.811, 100.0, 107.304],
+                                    "D75": [94.416, 100.0, 120.641],
+                                    "E": [100.0, 100.0, 100.0],
+                                    "F1": [94.791, 100.0, 103.191],
+                                    "F2": [103.280, 100.0, 69.026],
+                                    "F3": [108.968, 100.0, 51.965],
+                                    "F4": [114.961, 100.0, 40.963],
+                                    "F5": [93.369, 100.0, 98.636],
+                                    "F6": [102.148, 100.0, 62.074],
+                                    "F7": [95.792, 100.0, 107.687],
+                                    "F8": [97.115, 100.0, 81.135],
+                                    "F9": [102.116, 100.0, 67.826],
+                                    "F10": [99.001, 100.0, 83.134],
+                                    "F11": [103.866, 100.0, 65.627],
+                                    "F12": [111.428, 100.0, 40.353]}
+    else:
+        print("Warning! cie_version must be 1931 or 1964.")
+        return
+    return np.divide(xyz_reference_dictionary[illuminant], 100.0)
+
+
+def xyz2lab(data, cie_version="1931", illuminant="d65"):
+    xyz_reference = get_xyz_reference(cie_version, illuminant)
+
+    data = data
+    data[:, :, 0] = data[:, :, 0] / xyz_reference[0]
+    data[:, :, 1] = data[:, :, 1] / xyz_reference[1]
+    data[:, :, 2] = data[:, :, 2] / xyz_reference[2]
+
+    data = np.asarray(data)
+
+    # if data[x, y, c] > 0.008856, data[x, y, c] = data[x, y, c] ^ (1/3)
+    # else, data[x, y, c] = 7.787 * data[x, y, c] + 16/116
+    mask = data > 0.008856
+    data[mask] **= 1. / 3.
+    data[np.invert(mask)] *= 7.787
+    data[np.invert(mask)] += 16. / 116.
+
+    data = np.float32(data)
+    output = np.empty(np.shape(data), dtype=np.float32)
+    output[:, :, 0] = 116. * data[:, :, 1] - 16.
+    output[:, :, 1] = 500. * (data[:, :, 0] - data[:, :, 1])
+    output[:, :, 2] = 200. * (data[:, :, 1] - data[:, :, 2])
+
+    return output
+
+
+def lab2xyz(data, cie_version="1931", illuminant="d65"):
+    output = np.empty(np.shape(data), dtype=np.float32)
+
+    output[:, :, 1] = (data[:, :, 0] + 16.) / 116.
+    output[:, :, 0] = (data[:, :, 1] / 500.) + output[:, :, 1]
+    output[:, :, 2] = output[:, :, 1] - (data[:, :, 2] / 200.)
+
+    # if output[x, y, c] > 0.008856, output[x, y, c] ^ 3
+    # else, output[x, y, c] = ( output[x, y, c] - 16/116 ) / 7.787
+    output = np.asarray(output)
+    mask = output > 0.008856
+    output[mask] **= 3.
+    output[np.invert(mask)] -= 16 / 116
+    output[np.invert(mask)] /= 7.787
+
+    xyz_reference = get_xyz_reference(cie_version, illuminant)
+
+    output = np.float32(output)
+    output[:, :, 0] = output[:, :, 0] * xyz_reference[0]
+    output[:, :, 1] = output[:, :, 1] * xyz_reference[1]
+    output[:, :, 2] = output[:, :, 2] * xyz_reference[2]
+
+    return output
+
+
+def lab2lch(data):
+    output = np.empty(np.shape(data), dtype=np.float32)
+
+    output[:, :, 0] = data[:, :, 0]  # L transfers directly
+    output[:, :, 1] = np.power(np.power(data[:, :, 1], 2) + np.power(data[:, :, 2], 2), 0.5)
+    output[:, :, 2] = np.arctan2(data[:, :, 2], data[:, :, 1]) * 180 / np.pi
+
+    return output
+
+
+def lch2lab(data):
+    output = np.empty(np.shape(data), dtype=np.float32)
+
+    output[:, :, 0] = data[:, :, 0]  # L transfers directly
+    output[:, :, 1] = np.multiply(np.cos(data[:, :, 2] * np.pi / 180), data[:, :, 1])
+    output[:, :, 2] = np.multiply(np.sin(data[:, :, 2] * np.pi / 180), data[:, :, 1])
+
+    return output

OzUVGL/utils/io.py

@@ -0,0 +1,57 @@
+import cv2
+import json
+from pathlib import Path
+from fractions import Fraction
+
+
+def fraction_from_json(json_object):
+    if 'Fraction' in json_object:
+        return Fraction(*json_object['Fraction'])
+    return json_object
+
+
+def json_read(fname, **kwargs):
+    with open(fname) as j:
+        data = json.load(j, **kwargs)
+    return data
+
+
+def read_image(path):
+    png_path = Path(path)
+    raw_image = cv2.imread(str(png_path), cv2.IMREAD_UNCHANGED)
+    metadata = json_read(png_path.with_suffix('.json'), object_hook=fraction_from_json)
+
+    ill_path = Path(str(png_path).replace(".png", "_wb.json"))
+    if ill_path.with_suffix('.json').exists():
+        metadata["wb_estimation"] = json_read(ill_path, object_hook=fraction_from_json)
+    else:
+        print("WARNING! Illuminant estimations are not included in data folder and results may differ due to the randomness in the algorithm.")
+        print("For reproducibility, please include the corresponding files to that folder.")
+        metadata["wb_estimation"] = None
+    return raw_image, metadata
+
+
+def write_processed_as_jpg(out, dst_path, quality=100):
+    cv2.imwrite(dst_path, out, [cv2.IMWRITE_JPEG_QUALITY, quality])
+
+
+def write_illuminant_estimation(as_shot_neutral, dst_path):
+    with open(dst_path, 'w') as f:
+        json.dump(as_shot_neutral, f)
+
+
+def download_weights(url, fname):
+    import requests
+    r = requests.get(url, stream=True)
+    with open(fname, 'wb') as f:
+        total_length = int(r.headers.get('content-length'))
+        for chunk in r.iter_content(chunk_size=1024): 
+            if chunk:
+                f.write(chunk)
+                f.flush()
+                
+                
+def unzip(path_to_zip_file, directory_to_extract_to):
+    import zipfile
+    with zipfile.ZipFile(path_to_zip_file, 'r') as zip_ref:
+        zip_ref.extractall(directory_to_extract_to)

OzUVGL/utils/misc.py

@@ -0,0 +1,224 @@
+import numpy as np
+from math import ceil
+
+
+def decode_cfa_pattern(cfa_pattern):
+    cfa_dict = {0: 'B', 1: 'G', 2: 'R'}
+    return "".join([cfa_dict[x] for x in cfa_pattern])
+
+
+def outOfGamutClipping(I, range=1.):
+    """ Clips out-of-gamut pixels. """
+    if range == 1.:
+        I[I > 1] = 1  # any pixel is higher than 1, clip it to 1
+        I[I < 0] = 0  # any pixel is below 0, clip it to 0
+    else:
+        I[I > 255] = 255  # any pixel is higher than 255, clip it to 255
+        I[I < 0] = 0  # any pixel is below 0, clip it to 0
+    return I
+
+
+def ratios2floats(ratios):
+    floats = []
+    for ratio in ratios:
+        floats.append(float(ratio.num) / ratio.den)
+    return floats
+
+
+def fractions2floats(fractions):
+    floats = []
+    for fraction in fractions:
+        floats.append(float(fraction.numerator) / fraction.denominator)
+    return floats
+
+
+def gaussian(kernel_size, sigma):
+    # calculate which number to where the grid should be
+    # remember that, kernel_size[0] is the width of the kernel
+    # and kernel_size[1] is the height of the kernel
+    temp = np.floor(np.float32(kernel_size) / 2.)
+
+    # create the grid
+    # example: if kernel_size = [5, 3], then:
+    # x: array([[-2., -1.,  0.,  1.,  2.],
+    #           [-2., -1.,  0.,  1.,  2.],
+    #           [-2., -1.,  0.,  1.,  2.]])
+    # y: array([[-1., -1., -1., -1., -1.],
+    #           [ 0.,  0.,  0.,  0.,  0.],
+    #           [ 1.,  1.,  1.,  1.,  1.]])
+    x, y = np.meshgrid(np.linspace(-temp[0], temp[0], kernel_size[0]), np.linspace(-temp[1], temp[1], kernel_size[1]))
+
+    # Gaussian equation
+    temp = np.exp(-(x ** 2 + y ** 2) / (2. * sigma ** 2))
+
+    # make kernel sum equal to 1
+    return temp / np.sum(temp)
+
+
+def aspect_ratio_imresize(im, max_output=256):
+    h, w, c = im.shape
+    if max(h, w) > max_output:
+        ratio = max_output / max(h, w)
+        im = imresize.imresize(im, scalar_scale=ratio)
+        h, w, c = im.shape
+
+    if w % (2 ** 4) == 0:
+        new_size_w = w
+    else:
+        new_size_w = w + (2 ** 4) - w % (2 ** 4)
+
+    if h % (2 ** 4) == 0:
+        new_size_h = h
+    else:
+        new_size_h = h + (2 ** 4) - h % (2 ** 4)
+
+    new_size = (new_size_h, new_size_w)
+    if not ((h, w) == new_size):
+        im = imresize.imresize(im, output_shape=new_size)
+
+    return im
+
+
+def cubic(x):
+    x = np.array(x).astype(np.float64)
+    absx = np.absolute(x)
+    absx2 = np.multiply(absx, absx)
+    absx3 = np.multiply(absx2, absx)
+    f = np.multiply(1.5*absx3 - 2.5*absx2 + 1, absx <= 1) + np.multiply(-0.5*absx3 + 2.5*absx2 - 4*absx + 2, (1 < absx) & (absx <= 2))
+    return f
+
+
+def triangle(x):
+    x = np.array(x).astype(np.float64)
+    lessthanzero = np.logical_and((x>=-1),x<0)
+    greaterthanzero = np.logical_and((x<=1),x>=0)
+    f = np.multiply((x+1),lessthanzero) + np.multiply((1-x),greaterthanzero)
+    return f
+
+
+def deriveSizeFromScale(img_shape, scale):
+    output_shape = []
+    for k in range(2):
+        output_shape.append(int(ceil(scale[k] * img_shape[k])))
+    return output_shape
+
+
+def deriveScaleFromSize(img_shape_in, img_shape_out):
+    scale = []
+    for k in range(2):
+        scale.append(1.0 * img_shape_out[k] / img_shape_in[k])
+    return scale
+
+
+def contributions(in_length, out_length, scale, kernel, k_width):
+    if scale < 1:
+        h = lambda x: scale * kernel(scale * x)
+        kernel_width = 1.0 * k_width / scale
+    else:
+        h = kernel
+        kernel_width = k_width
+    x = np.arange(1, out_length+1).astype(np.float64)
+    u = x / scale + 0.5 * (1 - 1 / scale)
+    left = np.floor(u - kernel_width / 2)
+    P = int(ceil(kernel_width)) + 2
+    ind = np.expand_dims(left, axis=1) + np.arange(P) - 1 # -1 because indexing from 0
+    indices = ind.astype(np.int32)
+    weights = h(np.expand_dims(u, axis=1) - indices - 1) # -1 because indexing from 0
+    weights = np.divide(weights, np.expand_dims(np.sum(weights, axis=1), axis=1))
+    aux = np.concatenate((np.arange(in_length), np.arange(in_length - 1, -1, step=-1))).astype(np.int32)
+    indices = aux[np.mod(indices, aux.size)]
+    ind2store = np.nonzero(np.any(weights, axis=0))
+    weights = weights[:, ind2store]
+    indices = indices[:, ind2store]
+    return weights, indices
+
+
+def imresizemex(inimg, weights, indices, dim):
+    in_shape = inimg.shape
+    w_shape = weights.shape
+    out_shape = list(in_shape)
+    out_shape[dim] = w_shape[0]
+    outimg = np.zeros(out_shape)
+    if dim == 0:
+        for i_img in range(in_shape[1]):
+            for i_w in range(w_shape[0]):
+                w = weights[i_w, :]
+                ind = indices[i_w, :]
+                im_slice = inimg[ind, i_img].astype(np.float64)
+                outimg[i_w, i_img] = np.sum(np.multiply(np.squeeze(im_slice, axis=0), w.T), axis=0)
+    elif dim == 1:
+        for i_img in range(in_shape[0]):
+            for i_w in range(w_shape[0]):
+                w = weights[i_w, :]
+                ind = indices[i_w, :]
+                im_slice = inimg[i_img, ind].astype(np.float64)
+                outimg[i_img, i_w] = np.sum(np.multiply(np.squeeze(im_slice, axis=0), w.T), axis=0)        
+    if inimg.dtype == np.uint8:
+        outimg = np.clip(outimg, 0, 255)
+        return np.around(outimg).astype(np.uint8)
+    else:
+        return outimg
+    
+
+def imresizevec(inimg, weights, indices, dim):
+    wshape = weights.shape
+    if dim == 0:
+        weights = weights.reshape((wshape[0], wshape[2], 1, 1))
+        outimg =  np.sum(weights*((inimg[indices].squeeze(axis=1)).astype(np.float64)), axis=1)
+    elif dim == 1:
+        weights = weights.reshape((1, wshape[0], wshape[2], 1))
+        outimg =  np.sum(weights*((inimg[:, indices].squeeze(axis=2)).astype(np.float64)), axis=2)
+    if inimg.dtype == np.uint8:
+        outimg = np.clip(outimg, 0, 255)
+        return np.around(outimg).astype(np.uint8)
+    else:
+        return outimg
+    
+
+def resizeAlongDim(A, dim, weights, indices, mode="vec"):
+    if mode == "org":
+        out = imresizemex(A, weights, indices, dim)
+    else:
+        out = imresizevec(A, weights, indices, dim)
+    return out
+
+
+def imresize(I, scalar_scale=None, method='bicubic', output_shape=None, mode="vec"):
+    if method == 'bicubic':
+        kernel = cubic
+    elif method == 'bilinear':
+        kernel = triangle
+    else:
+        print ('Error: Unidentified method supplied')
+        
+    kernel_width = 4.0
+    # Fill scale and output_size
+    if scalar_scale is not None:
+        scalar_scale = float(scalar_scale)
+        scale = [scalar_scale, scalar_scale]
+        output_size = deriveSizeFromScale(I.shape, scale)
+    elif output_shape is not None:
+        scale = deriveScaleFromSize(I.shape, output_shape)
+        output_size = list(output_shape)
+    else:
+        print ('Error: scalar_scale OR output_shape should be defined!')
+        return
+    scale_np = np.array(scale)
+    order = np.argsort(scale_np)
+    weights = []
+    indices = []
+    for k in range(2):
+        w, ind = contributions(I.shape[k], output_size[k], scale[k], kernel, kernel_width)
+        weights.append(w)
+        indices.append(ind)
+    B = np.copy(I) 
+    flag2D = False
+    if B.ndim == 2:
+        B = np.expand_dims(B, axis=2)
+        flag2D = True
+    for k in range(2):
+        dim = order[k]
+        B = resizeAlongDim(B, dim, weights[dim], indices[dim], mode)
+    if flag2D:
+        B = np.squeeze(B, axis=2)
+    return B