|
|
import numpy as np
|
|
|
import cv2 as cv
|
|
|
from PIL import Image
|
|
|
|
|
|
def norm_mat(mat):
|
|
|
return cv.normalize(mat, None, 0, 255, cv.NORM_MINMAX).astype(np.uint8)
|
|
|
|
|
|
def minmax_dev(patch, mask):
|
|
|
c = patch[1, 1]
|
|
|
minimum, maximum, _, _ = cv.minMaxLoc(patch, mask)
|
|
|
if c < minimum:
|
|
|
return -1
|
|
|
if c > maximum:
|
|
|
return +1
|
|
|
return 0
|
|
|
|
|
|
def blk_filter(img, radius):
|
|
|
result = np.zeros_like(img, np.float32)
|
|
|
rows, cols = result.shape
|
|
|
block = 2 * radius + 1
|
|
|
for i in range(radius, rows, block):
|
|
|
for j in range(radius, cols, block):
|
|
|
result[
|
|
|
i - radius : i + radius + 1, j - radius : j + radius + 1
|
|
|
] = np.std(
|
|
|
img[i - radius : i + radius + 1, j - radius : j + radius + 1]
|
|
|
)
|
|
|
return cv.normalize(result, None, 0, 127, cv.NORM_MINMAX, cv.CV_8UC1)
|
|
|
|
|
|
def preprocess(image, channel=4, radius=2):
|
|
|
if not isinstance(image, np.ndarray):
|
|
|
image = np.array(image)
|
|
|
if channel == 0:
|
|
|
img = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
|
|
|
elif channel == 4:
|
|
|
b, g, r = cv.split(image.astype(np.float64))
|
|
|
img = cv.sqrt(cv.pow(b, 2) + cv.pow(g, 2) + cv.pow(r, 2))
|
|
|
else:
|
|
|
img = image[:, :, 3 - channel]
|
|
|
kernel = 3
|
|
|
border = kernel // 2
|
|
|
shape = (img.shape[0] - kernel + 1, img.shape[1] - kernel + 1, kernel, kernel)
|
|
|
strides = 2 * img.strides
|
|
|
patches = np.lib.stride_tricks.as_strided(img, shape=shape, strides=strides)
|
|
|
patches = patches.reshape((-1, kernel, kernel))
|
|
|
mask = np.full((kernel, kernel), 255, dtype=np.uint8)
|
|
|
mask[border, border] = 0
|
|
|
blocks = [0] * shape[0] * shape[1]
|
|
|
for i, patch in enumerate(patches):
|
|
|
blocks[i] = minmax_dev(patch, mask)
|
|
|
output = np.array(blocks).reshape(shape[:-2])
|
|
|
output = cv.copyMakeBorder(
|
|
|
output, border, border, border, border, cv.BORDER_CONSTANT
|
|
|
)
|
|
|
low = output == -1
|
|
|
high = output == +1
|
|
|
minmax = np.zeros_like(image)
|
|
|
if radius > 0:
|
|
|
radius += 3
|
|
|
low = blk_filter(low, radius)
|
|
|
high = blk_filter(high, radius)
|
|
|
if channel <= 2:
|
|
|
minmax[:, :, 2 - channel] = low
|
|
|
minmax[:, :, 2 - channel] += high
|
|
|
else:
|
|
|
minmax = np.repeat(low[:, :, np.newaxis], 3, axis=2)
|
|
|
minmax += np.repeat(high[:, :, np.newaxis], 3, axis=2)
|
|
|
minmax = norm_mat(minmax)
|
|
|
else:
|
|
|
if channel == 0:
|
|
|
minmax[low] = [0, 0, 255]
|
|
|
minmax[high] = [0, 0, 255]
|
|
|
elif channel == 1:
|
|
|
minmax[low] = [0, 255, 0]
|
|
|
minmax[high] = [0, 255, 0]
|
|
|
elif channel == 2:
|
|
|
minmax[low] = [255, 0, 0]
|
|
|
minmax[high] = [255, 0, 0]
|
|
|
elif channel == 3:
|
|
|
minmax[low] = [255, 255, 255]
|
|
|
minmax[high] = [255, 255, 255]
|
|
|
return Image.fromarray(minmax) |
