Upload 6 files

.gitignore

@@ -0,0 +1,137 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+
+# demo folder
+/demo/enhanced/*
+exposure_corrector (copy).py
+
+# notebooks
+*.ipynb

README.md

@@ -1,10 +1,67 @@
----
-title: Imageenhancement2
-emoji: 🌖
-colorFrom: green
-colorTo: purple
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Low-light-Image-Enhancement
+Python implementation of two low-light image enhancement techniques via illumination map estimation, based on the following papers:
+ * Dual Illumination Estimation for Robust Exposure Correction [[link](https://arxiv.org/pdf/1910.13688.pdf)]
+ * LIME: Low-light Image Enhancement via Illumination Map Estimation [[link](https://ieeexplore.ieee.org/document/7782813)]
+
+Both methods are based on retinex modelling, and aim at estimating the illumination map by preserving the prominent structure of the image, while removing the redundant texture details. To do this, the same optimization formulation is used by both papers (see references). The novelty introduced by the first paper (called DUAL below) compared to the second (called LIME below) is the estimation of this map for the original image, and for its inverted version, which allows to correct both the under-exposed and over-exposed parts of the image.
+
+The code implemented in this repository allows the use of both methods, which can be easily selected from the script parameters.
+
+## Installation
+This implementation runs on python >= 3.7, use pip to install dependencies:
+```
+pip3 install -r requirements.txt
+```
+
+## Usage
+Use the `demo.py` script to enhance your images.
+```
+usage: demo.py [-h] [-f FOLDER] [-g GAMMA] [-l LAMBDA_] [-ul] [-s SIGMA]
+               [-bc BC] [-bs BS] [-be BE] [-eps EPS]
+
+Python implementation of two low-light image enhancement techniques via illumination map estimation.
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -f FOLDER, --folder FOLDER
+                        folder path to test images.
+  -g GAMMA, --gamma GAMMA
+                        the gamma correction parameter.
+  -l LAMBDA_, --lambda_ LAMBDA_
+                        the weight for balancing the two terms in the illumination refinement optimization objective.
+  -ul, --lime           Use the LIME method. By default, the DUAL method is used.
+  -s SIGMA, --sigma SIGMA
+                        Spatial standard deviation for spatial affinity based Gaussian weights.
+  -bc BC                parameter for controlling the influence of Mertens's contrast measure.
+  -bs BS                parameter for controlling the influence of Mertens's saturation measure.
+  -be BE                parameter for controlling the influence of Mertens's well exposedness measure.
+  -eps EPS              constant to avoid computation instability.
+```
+
+### Example
+```
+python3 demo.py -f ./demo/ -l 0.15 -g 0.6
+```
+
+### Result
+Low Light Image             |  Enhanced Image
+:-------------------------:|:-------------------------:
+![](demo/2.bmp)  |  ![](demo/enhanced/2_DUAL_g0.6_l0.15.bmp)
+
+### TODO
+ - [ ] Add a fourier based solver to speed up the inference
+ 
+ 
+### :mortar_board: Citation
+If you find this work useful in your research, please consider citing:
+```
+@misc{lowlightpython,
+  author = {Souhaib Attaiki},
+  title = {Low light Image Enhancement},
+  year = {2020},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://github.com/pvnieo/Low-light-Image-Enhancement}},
+}
+
+```

demo.py

@@ -0,0 +1,63 @@
+# std
+import argparse
+from argparse import RawTextHelpFormatter
+import glob
+from os import makedirs
+from os.path import join, exists, basename, splitext
+# 3p
+import cv2
+from tqdm import tqdm
+# project
+from exposure_enhancement import enhance_image_exposure
+
+
+def main(args):
+    # load images
+    imdir = args.folder
+    ext = ['png', 'jpg', 'bmp']    # Add image formats here
+    files = []
+    [files.extend(glob.glob(imdir + '*.' + e)) for e in ext]
+    images = [cv2.imread(file) for file in files]
+
+    # create save directory
+    directory = join(imdir, "enhanced")
+    if not exists(directory):
+        makedirs(directory)
+
+    # enhance images
+    for i, image in tqdm(enumerate(images), desc="Enhancing images"):
+        enhanced_image = enhance_image_exposure(image, args.gamma, args.lambda_, not args.lime,
+                                                sigma=args.sigma, bc=args.bc, bs=args.bs, be=args.be, eps=args.eps)
+        filename = basename(files[i])
+        name, ext = splitext(filename)
+        method = "LIME" if args.lime else "DUAL"
+        corrected_name = f"{name}_{method}_g{args.gamma}_l{args.lambda_}{ext}"
+        cv2.imwrite(join(directory, corrected_name), enhanced_image)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Python implementation of two low-light image enhancement techniques via illumination map estimation.",
+        formatter_class=RawTextHelpFormatter
+    )
+    parser.add_argument("-f", '--folder', default='./demo/', type=str,
+                        help="folder path to test images.")
+    parser.add_argument("-g", '--gamma', default=0.6, type=float,
+                        help="the gamma correction parameter.")
+    parser.add_argument("-l", '--lambda_', default=0.15, type=float,
+                        help="the weight for balancing the two terms in the illumination refinement optimization objective.")
+    parser.add_argument("-ul", "--lime", action='store_true',
+                        help="Use the LIME method. By default, the DUAL method is used.")
+    parser.add_argument("-s", '--sigma', default=3, type=int,
+                        help="Spatial standard deviation for spatial affinity based Gaussian weights.")
+    parser.add_argument("-bc", default=1, type=float,
+                        help="parameter for controlling the influence of Mertens's contrast measure.")
+    parser.add_argument("-bs", default=1, type=float,
+                        help="parameter for controlling the influence of Mertens's saturation measure.")
+    parser.add_argument("-be", default=1, type=float,
+                        help="parameter for controlling the influence of Mertens's well exposedness measure.")
+    parser.add_argument("-eps", default=1e-3, type=float,
+                        help="constant to avoid computation instability.")
+
+    args = parser.parse_args()
+    main(args)

exposure_enhancement.py

@@ -0,0 +1,190 @@
+# 3p
+import numpy as np
+import cv2
+from scipy.spatial import distance
+from scipy.ndimage.filters import convolve
+from scipy.sparse import diags, csr_matrix
+from scipy.sparse.linalg import spsolve
+# project
+from utils import get_sparse_neighbor
+
+
+def create_spacial_affinity_kernel(spatial_sigma: float, size: int = 15):
+    """Create a kernel (`size` * `size` matrix) that will be used to compute the he spatial affinity based Gaussian weights.
+
+    Arguments:
+        spatial_sigma {float} -- Spatial standard deviation.
+
+    Keyword Arguments:
+        size {int} -- size of the kernel. (default: {15})
+
+    Returns:
+        np.ndarray - `size` * `size` kernel
+    """
+    kernel = np.zeros((size, size))
+    for i in range(size):
+        for j in range(size):
+            kernel[i, j] = np.exp(-0.5 * (distance.euclidean((i, j), (size // 2, size // 2)) ** 2) / (spatial_sigma ** 2))
+
+    return kernel
+
+
+def compute_smoothness_weights(L: np.ndarray, x: int, kernel: np.ndarray, eps: float = 1e-3):
+    """Compute the smoothness weights used in refining the illumination map optimization problem.
+
+    Arguments:
+        L {np.ndarray} -- the initial illumination map to be refined.
+        x {int} -- the direction of the weights. Can either be x=1 for horizontal or x=0 for vertical.
+        kernel {np.ndarray} -- spatial affinity matrix
+
+    Keyword Arguments:
+        eps {float} -- small constant to avoid computation instability. (default: {1e-3})
+
+    Returns:
+        np.ndarray - smoothness weights according to direction x. same dimension as `L`.
+    """
+    Lp = cv2.Sobel(L, cv2.CV_64F, int(x == 1), int(x == 0), ksize=1)
+    T = convolve(np.ones_like(L), kernel, mode='constant')
+    T = T / (np.abs(convolve(Lp, kernel, mode='constant')) + eps)
+    return T / (np.abs(Lp) + eps)
+
+
+def fuse_multi_exposure_images(im: np.ndarray, under_ex: np.ndarray, over_ex: np.ndarray,
+                               bc: float = 1, bs: float = 1, be: float = 1):
+    """perform the exposure fusion method used in the DUAL paper.
+
+    Arguments:
+        im {np.ndarray} -- input image to be enhanced.
+        under_ex {np.ndarray} -- under-exposure corrected image. same dimension as `im`.
+        over_ex {np.ndarray} -- over-exposure corrected image. same dimension as `im`.
+
+    Keyword Arguments:
+        bc {float} -- parameter for controlling the influence of Mertens's contrast measure. (default: {1})
+        bs {float} -- parameter for controlling the influence of Mertens's saturation measure. (default: {1})
+        be {float} -- parameter for controlling the influence of Mertens's well exposedness measure. (default: {1})
+
+    Returns:
+        np.ndarray -- the fused image. same dimension as `im`.
+    """
+    merge_mertens = cv2.createMergeMertens(bc, bs, be)
+    images = [np.clip(x * 255, 0, 255).astype("uint8") for x in [im, under_ex, over_ex]]
+    fused_images = merge_mertens.process(images)
+    return fused_images
+
+
+def refine_illumination_map_linear(L: np.ndarray, gamma: float, lambda_: float, kernel: np.ndarray, eps: float = 1e-3):
+    """Refine the illumination map based on the optimization problem described in the two papers.
+       This function use the sped-up solver presented in the LIME paper.
+
+    Arguments:
+        L {np.ndarray} -- the illumination map to be refined.
+        gamma {float} -- gamma correction factor.
+        lambda_ {float} -- coefficient to balance the terms in the optimization problem.
+        kernel {np.ndarray} -- spatial affinity matrix.
+
+    Keyword Arguments:
+        eps {float} -- small constant to avoid computation instability (default: {1e-3}).
+
+    Returns:
+        np.ndarray -- refined illumination map. same shape as `L`.
+    """
+    # compute smoothness weights
+    wx = compute_smoothness_weights(L, x=1, kernel=kernel, eps=eps)
+    wy = compute_smoothness_weights(L, x=0, kernel=kernel, eps=eps)
+
+    n, m = L.shape
+    L_1d = L.copy().flatten()
+
+    # compute the five-point spatially inhomogeneous Laplacian matrix
+    row, column, data = [], [], []
+    for p in range(n * m):
+        diag = 0
+        for q, (k, l, x) in get_sparse_neighbor(p, n, m).items():
+            weight = wx[k, l] if x else wy[k, l]
+            row.append(p)
+            column.append(q)
+            data.append(-weight)
+            diag += weight
+        row.append(p)
+        column.append(p)
+        data.append(diag)
+    F = csr_matrix((data, (row, column)), shape=(n * m, n * m))
+
+    # solve the linear system
+    Id = diags([np.ones(n * m)], [0])
+    A = Id + lambda_ * F
+    L_refined = spsolve(csr_matrix(A), L_1d, permc_spec=None, use_umfpack=True).reshape((n, m))
+
+    # gamma correction
+    L_refined = np.clip(L_refined, eps, 1) ** gamma
+
+    return L_refined
+
+
+def correct_underexposure(im: np.ndarray, gamma: float, lambda_: float, kernel: np.ndarray, eps: float = 1e-3):
+    """correct underexposudness using the retinex based algorithm presented in DUAL and LIME paper.
+
+    Arguments:
+        im {np.ndarray} -- input image to be corrected.
+        gamma {float} -- gamma correction factor.
+        lambda_ {float} -- coefficient to balance the terms in the optimization problem.
+        kernel {np.ndarray} -- spatial affinity matrix.
+
+    Keyword Arguments:
+        eps {float} -- small constant to avoid computation instability (default: {1e-3})
+
+    Returns:
+        np.ndarray -- image underexposudness corrected. same shape as `im`.
+    """
+
+    # first estimation of the illumination map
+    L = np.max(im, axis=-1)
+    # illumination refinement
+    L_refined = refine_illumination_map_linear(L, gamma, lambda_, kernel, eps)
+
+    # correct image underexposure
+    L_refined_3d = np.repeat(L_refined[..., None], 3, axis=-1)
+    im_corrected = im / L_refined_3d
+    return im_corrected
+
+# TODO: resize image if too large, optimization take too much time
+
+
+def enhance_image_exposure(im: np.ndarray, gamma: float, lambda_: float, dual: bool = True, sigma: int = 3,
+                           bc: float = 1, bs: float = 1, be: float = 1, eps: float = 1e-3):
+    """Enhance input image, using either DUAL method, or LIME method. For more info, please see original papers.
+
+    Arguments:
+        im {np.ndarray} -- input image to be corrected.
+        gamma {float} -- gamma correction factor.
+        lambda_ {float} -- coefficient to balance the terms in the optimization problem (in DUAL and LIME).
+
+    Keyword Arguments:
+        dual {bool} -- boolean variable to indicate enhancement method to be used (either DUAL or LIME) (default: {True})
+        sigma {int} -- Spatial standard deviation for spatial affinity based Gaussian weights. (default: {3})
+        bc {float} -- parameter for controlling the influence of Mertens's contrast measure. (default: {1})
+        bs {float} -- parameter for controlling the influence of Mertens's saturation measure. (default: {1})
+        be {float} -- parameter for controlling the influence of Mertens's well exposedness measure. (default: {1})
+        eps {float} -- small constant to avoid computation instability (default: {1e-3})
+
+    Returns:
+        np.ndarray -- image exposure enhanced. same shape as `im`.
+    """
+    # create spacial affinity kernel
+    kernel = create_spacial_affinity_kernel(sigma)
+
+    # correct underexposudness
+    im_normalized = im.astype(float) / 255.
+    under_corrected = correct_underexposure(im_normalized, gamma, lambda_, kernel, eps)
+
+    if dual:
+        # correct overexposure and merge if DUAL method is selected
+        inv_im_normalized = 1 - im_normalized
+        over_corrected = 1 - correct_underexposure(inv_im_normalized, gamma, lambda_, kernel, eps)
+        # fuse images
+        im_corrected = fuse_multi_exposure_images(im_normalized, under_corrected, over_corrected, bc, bs, be)
+    else:
+        im_corrected = under_corrected
+
+    # convert to 8 bits and returns
+    return np.clip(im_corrected * 255, 0, 255).astype("uint8")

requirements.txt

@@ -0,0 +1,4 @@
+numpy
+scipy
+opencv-python
+tqdm

utils.py

@@ -0,0 +1,26 @@
+
+
+def get_sparse_neighbor(p: int, n: int, m: int):
+    """Returns a dictionnary, where the keys are index of 4-neighbor of `p` in the sparse matrix,
+       and values are tuples (i, j, x), where `i`, `j` are index of neighbor in the normal matrix,
+       and x is the direction of neighbor.
+
+    Arguments:
+        p {int} -- index in the sparse matrix.
+        n {int} -- number of rows in the original matrix (non sparse).
+        m {int} -- number of columns in the original matrix.
+
+    Returns:
+        dict -- dictionnary containing indices of 4-neighbors of `p`.
+    """
+    i, j = p // m, p % m
+    d = {}
+    if i - 1 >= 0:
+        d[(i - 1) * m + j] = (i - 1, j, 0)
+    if i + 1 < n:
+        d[(i + 1) * m + j] = (i + 1, j, 0)
+    if j - 1 >= 0:
+        d[i * m + j - 1] = (i, j - 1, 1)
+    if j + 1 < m:
+        d[i * m + j + 1] = (i, j + 1, 1)
+    return d