File size: 3,340 Bytes
1a41d53 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 | import tqdm
import numpy as np
from scipy import fft
from skimage import io, exposure, img_as_ubyte, img_as_float
def firstOrderDerivative(n, k=1):
return np.eye(n) * (-1) + np.eye(n, k=k)
def toeplitizMatrix(n, row):
vecDD = np.zeros(n)
vecDD[0] = 4
vecDD[1] = -1
vecDD[row] = -1
vecDD[-1] = -1
vecDD[-row] = -1
return vecDD
def vectorize(matrix):
return matrix.T.ravel()
def reshape(vector, row, col):
return vector.reshape((row, col), order='F')
class LIME:
def __init__(self, iterations=10, alpha=2, rho=1.5, gamma=0.7, strategy=2, *args, **kwargs):
self.iterations = iterations
self.alpha = alpha
self.rho = rho
self.gamma = gamma
self.strategy = strategy
def load(self, imgPath):
if isinstance(imgPath, str):
self.L = img_as_float(io.imread(imgPath))
elif isinstance(imgPath, np.ndarray):
self.L = img_as_float(imgPath)
else:
print(f"The input should be path to image of numpy array.")
self.row = self.L.shape[0]
self.col = self.L.shape[1]
self.T_hat = np.max(self.L, axis=2)
self.dv = firstOrderDerivative(self.row)
self.dh = firstOrderDerivative(self.col, -1)
self.vecDD = toeplitizMatrix(self.row * self.col, self.row)
self.W = self.weightingStrategy()
def weightingStrategy(self):
if self.strategy == 2:
dTv = self.dv @ self.T_hat
dTh = self.T_hat @ self.dh
Wv = 1 / (np.abs(dTv) + 1)
Wh = 1 / (np.abs(dTh) + 1)
return np.vstack([Wv, Wh])
else:
return np.ones((self.row * 2, self.col))
def __T_subproblem(self, G, Z, u):
X = G - Z / u
Xv = X[:self.row, :]
Xh = X[self.row:, :]
temp = self.dv @ Xv + Xh @ self.dh
numerator = fft.fft(vectorize(2 * self.T_hat + u * temp))
denominator = fft.fft(self.vecDD * u) + 2
T = fft.ifft(numerator / denominator)
T = np.real(reshape(T, self.row, self.col))
return exposure.rescale_intensity(T, (0, 1), (0.001, 1))
def __G_subproblem(self, T, Z, u, W):
dT = self.__derivative(T)
epsilon = self.alpha * W / u
X = dT + Z / u
return np.sign(X) * np.maximum(np.abs(X) - epsilon, 0)
def __Z_subproblem(self, T, G, Z, u):
dT = self.__derivative(T)
return Z + u * (dT - G)
def __u_subproblem(self, u):
return u * self.rho
def __derivative(self, matrix):
v = self.dv @ matrix
h = matrix @ self.dh
return np.vstack([v, h])
def illumMap(self):
T = np.zeros((self.row, self.col))
G = np.zeros((self.row * 2, self.col))
Z = np.zeros((self.row * 2, self.col))
u = 1
for _ in tqdm.trange(0, self.iterations):
T = self.__T_subproblem(G, Z, u)
G = self.__G_subproblem(T, Z, u, self.W)
Z = self.__Z_subproblem(T, G, Z, u)
u = self.__u_subproblem(u)
return T ** self.gamma
def enhance(self):
self.T = self.illumMap()
self.R = self.L / np.repeat(self.T[:, :, np.newaxis], 3, axis=2)
self.R = exposure.rescale_intensity(self.R, (0, 1))
self.R = img_as_ubyte(self.R)
return self.R
|