def hisEqulColor(img):
if len(img.shape) == 2:
return hisEqul(img)
ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCR_CB)
channels = cv2.split(ycrcb)
cv2.equalizeHist(channels[0], channels[0])
cv2.merge(channels, ycrcb)
cv2.cvtColor(ycrcb, cv2.COLOR_YCR_CB2BGR, img)
return img
def refactor(self):
for k in range(3): # three channels
# coarse between 0.5~0.5 coefficients between -1~1
for i in range(len(self.coefficients[k]),
self.num): # complete coefficient
height = 2 * len(self.coefficients[k][i - 1][0])
width = 2 * len(self.coefficients[k][i - 1][0][0])
self.coefficients[k].append([
array([[0. for i in range(width)] for j in range(height)])
for k in range(3)
])
for i in range(self.num):
self.coarse_coef[k] = self.__lifting_scheme_reverse(
self.coarse_coef[k], self.coefficients[k][i][0], 0)
fine_coef = self.__lifting_scheme_reverse(
self.coefficients[k][i][1], self.coefficients[k][i][2], 0)
self.coarse_coef[k] = self.__lifting_scheme_reverse(
self.coarse_coef[k], fine_coef, 1)
self.coarse_coef[k] = self.coarse_coef[k].astype(float) * iinfo(
uint8).max # convert back to integer
self.coarse_coef[k] = self.coarse_coef[k].astype(uint8)
self.img = cv2.merge(
[self.coarse_coef[0], self.coarse_coef[1], self.coarse_coef[2]])
self.img = cv2.cvtColor(self.img,
cv2.COLOR_YCrCb2BGR) # convert YUV to RGB
def transfertColor(src, ref, output,gamma):
img_src = read(src)
tonemap = reinhard(img_src)
write("in1.jpg",tonemap)
img_src = adjust_gamma(img_src,gamma)
img_src = BGRtoLalphabeta(img_src)
img_ref = read(ref)
tonemap = reinhard(img_ref)
write("in2.jpg",tonemap)
img_ref = adjust_gamma(img_ref,gamma)
img_ref = BGRtoLalphabeta(img_ref)
mean_src, stddev_src = cv2.meanStdDev(img_src)
mean_ref, stddev_ref = cv2.meanStdDev(img_ref)
split_src = cv2.split(img_src)
img_out = cv2.merge((computeColor(split_src[0], mean_src[0], stddev_src[0], mean_ref[0], stddev_ref[0]),
computeColor(split_src[1], mean_src[1], stddev_src[1], mean_ref[1], stddev_ref[1]),
computeColor(split_src[2], mean_src[2], stddev_src[2], mean_ref[2], stddev_ref[2])))
img_out = LalphabetatoBGR(img_out)
img_out = adjust_gamma(img_out,1./gamma)
write(output, img_out)
tonemap = logarithme(img_out)
write("out.jpg",tonemap)
def addAlpha(self, img):
b_chan, g_chan, r_chan = cv2.split(img)
alpha_chan = np.ones(b_chan.shape, dtype=b_chan.dtype) * 50
img = cv2.merge((b_chan, g_chan, r_chan, alpha_chan))
return img
def Histogram_EQ(processed_imgs,eq_direc):
if not os.path.exists(eq_direc):
os.mkdir(eq_direc)
i = 0
for file in os.listdir(processed_imgs):
print('Equalizing photo: ',i)
filename = f"{processed_imgs}/{i}.jpg"
img_eq = cv2.imread(filename, 1)
img_eq = cv2.cvtColor(img_eq, cv2.COLOR_HSV2RGB)
R, G, B = cv2.split(img_eq)
#apply CLAHE to each RGB channel
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
output2_R = clahe.apply(R)
output2_G = clahe.apply(G)
output2_B = clahe.apply(B)
#Merge the channels again
img_eq = cv2.merge((output2_R, output2_G, output2_B))
img = Image.open(filename)
nameEq = f"{eq_direc}/{i}.jpg"
img.save(nameEq)
i +=1
shutil.rmtree(processed_imgs)
def gray_world(img: np.ndarray):
b, g, r = cv2.split(img)[:3]
b_mean, g_mean, r_mean = np.mean(b), np.mean(g), np.mean(r)
k = (b_mean + g_mean + r_mean) / 3
kb, kg, kr = k / b_mean, k / g_mean, k / r_mean
return cv2.merge(
(cv2.addWeighted(b, kb, 0, 0, 0), cv2.addWeighted(g, kg, 0, 0, 0), cv2.addWeighted(r, kr, 0, 0, 0)))
def color():
img = cv2.imread('Lenna.jpg')
b_img,g_img,r_img = cv2.split(img)
b_bin = histogram(b_img)
g_bin = histogram(g_img)
r_bin = histogram(r_img)
b_img_eq = equalize(b_img,b_bin)
g_img_eq = equalize(g_img,g_bin)
r_img_eq = equalize(r_img,r_bin)
b_bin_eq = histogram(b_img_eq)
g_bin_eq = histogram(g_img_eq)
r_bin_eq = histogram(r_img_eq)
plt.subplot(2,3,1)
plt.bar(np.arange(b_bin.shape[0]),b_bin,align = 'center',color = 'b')
plt.subplot(2,3,4)
plt.bar(np.arange(b_bin_eq.shape[0]),b_bin_eq,align = 'center',color = 'b')
plt.subplot(2,3,2)
plt.bar(np.arange(g_bin.shape[0]),g_bin,align = 'center',color = 'g')
plt.subplot(2,3,5)
plt.bar(np.arange(g_bin_eq.shape[0]),g_bin_eq,align = 'center',color = 'g')
plt.subplot(2,3,3)
plt.bar(np.arange(r_bin.shape[0]),r_bin,align = 'center',color = 'r')
plt.subplot(2,3,6)
plt.bar(np.arange(r_bin_eq.shape[0]),r_bin_eq,align = 'center',color = 'r')
plt.show()
# plt.savefig('color_hist_eq.png')
plt.close()
tmp = np.zeros_like(img)
tmp[...,0] = b_img
cv2.imwrite('b_img.jpg',tmp)
tmp = np.zeros_like(img)
tmp[...,1] = g_img
cv2.imwrite('g_img.jpg',tmp)
tmp = np.zeros_like(img)
tmp[...,2] = r_img
cv2.imwrite('r_img.jpg',tmp)
tmp = np.zeros_like(img)
tmp[...,0] = b_img_eq
cv2.imwrite('b_img_eq.jpg',tmp)
tmp = np.zeros_like(img)
tmp[...,1] = g_img_eq
cv2.imwrite('g_img_eq.jpg',tmp)
tmp = np.zeros_like(img)
tmp[...,2] = r_img_eq
cv2.imwrite('r_img_eq.jpg',tmp)
canvas = cv2.merge([b_img_eq,g_img_eq,r_img_eq])
cv2.imwrite("bgr.jpg",canvas)
ttt = cv2.imread("bgr.jpg")
cv2.imshow("bgr", ttt)
cv2.waitKey(0)
def colorTransfer(src: str, ref: str, output: str, gamma: float):
img_src = cv2.imread(src, cv2.IMREAD_ANYCOLOR | cv2.IMREAD_ANYDEPTH)
tonemap = reinhard(img_src)
cv2.imwrite("in1.jpg", tonemap)
img_src = adjust_gamma(img_src, gamma)
img_src = BGRtoLab(img_src)
img_ref = cv2.imread(ref, cv2.IMREAD_ANYCOLOR | cv2.IMREAD_ANYDEPTH)
tonemap = reinhard(img_ref)
cv2.imwrite("in2.jpg", tonemap)
img_ref = adjust_gamma(img_ref, gamma)
img_ref = BGRtoLab(img_ref)
mean_src, stddev_src = cv2.meanStdDev(img_src)
mean_ref, stddev_ref = cv2.meanStdDev(img_ref)
split_src = cv2.split(img_src)
img_out = cv2.merge((computeColor(split_src[0], mean_src[0], stddev_src[0],
mean_ref[0], stddev_ref[0]),
computeColor(split_src[1], mean_src[1], stddev_src[1],
mean_ref[1], stddev_ref[1]),
computeColor(split_src[2], mean_src[2], stddev_src[2],
mean_ref[2], stddev_ref[2])))
img_out = LabtoRGB(img_out)
img_out = adjust_gamma(img_out, 1. / gamma)
cv2.imwrite(output, img_out)
tonemap = logarithme(img_out)
cv2.imwrite("out.jpg", tonemap)
def random_bright_image(self, image, brightness_range):
"""
Randomly brighten the given image.
The intent is to allow a model to generalize across images trained on different lighting levels.
Parameters
----------
image : ndim np.array
image to be brightened
brightness_range : tuple of ints
specifies the range from within the brightness value (in pixels)
should be chosen
Returns
-------
brightened image as np.array
"""
hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
h, s, v = cv2.split(hsv)
start_range, end_range = brightness_range
rand_val = random.randint(start_range, end_range)
v = cv2.add(v, rand_val)
v[v > 255] = 255
v[v < 0] = 0
final_hsv = cv2.merge((h, s, v))
image = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2RGB)
return np.copy(image)
def img_fusion(img1, img2):
print(img1.shape, img2.shape)
# img1 = cv.resize(img1, (640, 480))
# img2 = cv.resize(img2, (640, 480))
# cv.imshow("img1", img1)
print(img1.shape)
# 分离YUV数据
yuv1 = cv.cvtColor(img1, cv.COLOR_BGR2YCrCb)
y1, u1, v1 = cv.split(yuv1)
yuv2 = cv.cvtColor(img2, cv.COLOR_BGR2YCrCb)
y2, u2, v2 = cv.split(yuv2)
# cv.imshow("y1", y1)
# cv.imshow("y2", y2)
# Y值均衡化
clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
y2 = clahe.apply(y2)
# Y像素范围压缩
img_pixels_range(y1, 128)
img_pixels_range(y2, 128)
cv.imshow("y1", y1)
cv.imshow("y2", y2)
# y3 = cv.add(y1, y2)
y3 = cv.addWeighted(y1, 0.6, y2, 0.4, 0)
cv.imshow("y3", y3)
img3 = cv.merge([y3, u1, v1])
img3 = cv.cvtColor(img3, cv.COLOR_YCrCb2BGR)
cv.imshow("img3", img3)
cv.imwrite(r".04-picture-fusion_images/opencv.jpg", img3)
def singleScaleRetinex(img, size):
# cv2.imshow('G', cv2.GaussianBlur(img, (size, size), 0))
b_gray, g_gray, r_gray = cv2.split(img)
Rb_ssr = ssr_c(b_gray, size)
Rg_ssr = ssr_c(g_gray, size)
Rr_ssr = ssr_c(r_gray, size)
R = cv2.merge([Rb_ssr, Rg_ssr, Rr_ssr])
return R
def display(self):
if self.destroyedImg is not None:
b, g, r = cv2.split(self.destroyedImg)
img = Image.fromarray(cv2.merge((r, g, b)))
tkImage = ImageTk.PhotoImage(image=img)
canvas1.configure(image=tkImage)
canvas1.image = tkImage
if self.mask is not None:
tkImage = ImageTk.PhotoImage(image=Image.fromarray(self.mask))
canvas2.configure(image=tkImage)
canvas2.image = tkImage
if self.repaired is not None:
b, g, r = cv2.split(self.repaired)
img = Image.fromarray(cv2.merge((r, g, b)))
tkImage = ImageTk.PhotoImage(image=img)
canvas3.configure(image=tkImage)
canvas3.image = tkImage
def whiten(img: np.ndarray):
# # 白化
channels = cv2.split(img)
new_channels = []
for channel in channels:
mean_ = np.mean(channel.ravel())
std_ = np.std(channel.ravel())
new_channels.append((channel - mean_) / std_)
return cv2.merge(new_channels)
def increase_sat(img):
img = cv2.cvtColor(img, cv2.COLOR_RGB2HSV).astype('float32')
h, s, v = cv2.split(img)
s = s + 200
s = np.clip(s, 0, 255)
imghsv = cv2.merge((h, s, v))
imghsv = cv2.cvtColor(imghsv.astype('uint8'), cv2.COLOR_HSV2RGB)
return imghsv
def increase_brightness(img, value=30):
hsv = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
h, s, v = cv2.split(hsv)
lim = 255 - value
v[v > lim] = 255
v[v <= lim] += value
final_hsv = cv2.merge((h, s, v))
img = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)
return img
def spin(self, img, angle=1):
if angle % 4 == 1:
b, g, r = cv2.split(img)
return cv2.merge((b.T, g.T, r.T))
elif angle % 4 == 2:
return self.mirror(img, 2)
elif angle % 4 == 3:
return self.mirror(self.spin(img, 1), 1)
else:
return img
def img_ch_split(img):
r, g, b = cv.split(img)
# cv.imshow("r", r)
# cv.imshow("g", g)
# cv.imshow("b", b)
img[:, :, 1] = 0
img[:, :, 2] = 0
cv.imshow("ch0", img)
bgr = cv.merge([b, g, r])
cv.imshow("bgr", bgr)
def preprocess(self, image):
# split the image into channels
B, G, R = cv2.split(image.astype('float32'))
# subtract the means for each channel
R -= self.rmean
G -= self.gmean
B -= self.bmean
# merge the channels back together and return the image
return cv2.merge([B, G, R])
def base():
if request.method == 'GET':
return "<h1>Crop AI</h1>"
if request.method == 'POST':
if 'InputImg' not in request.files:
print("No file part")
return redirect(request.url)
file = request.files['InputImg']
if file.filename == '':
print('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
filestr = request.files['InputImg'].read()
img = cv2.imdecode(np.fromstring(filestr, np.uint8),
cv2.IMREAD_COLOR)
img = cv2.resize(img, (96, 96), interpolation=cv2.INTER_AREA)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
# find the green color
mask_green = cv2.inRange(hsv, (36, 0, 0), (86, 255, 255))
# find the brown color
mask_brown = cv2.inRange(hsv, (8, 60, 20), (145, 255, 255))
# find the yellow color in the leaf
mask_yellow = cv2.inRange(hsv, (5, 42, 143), (145, 255, 255))
# find the black color in the leaf
mask_black = cv2.inRange(hsv, (100, 100, 100), (127, 127, 127))
# find any of the four colors(green or brown or yellow or black) in the image
mask = cv2.bitwise_or(mask_green, mask_brown)
mask = cv2.bitwise_or(mask, mask_yellow)
mask = cv2.bitwise_or(mask, mask_black)
# Bitwise-AND mask and original image
res = cv2.bitwise_and(img, img, mask=mask)
# Gaussian blur with 3x3 kernel
blur_img = cv2.GaussianBlur(res, (3, 3), 0)
# Histogram equalization
B, G, R = cv2.split(blur_img)
output_R = cv2.equalizeHist(R)
output_G = cv2.equalizeHist(G)
output_B = cv2.equalizeHist(B)
img = cv2.merge((output_R, output_G, output_B))
img = img / 255
img_array = np.expand_dims(img, axis=0)
output = label_dictionary[model.predict(img_array)[0].argmax()]
return output
def identify_rivers(image):
image_hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
lower_blue = np.array([90, 20, 38])
upper_blue = np.array([110, 255, 255])
rivers_mask = cv2.inRange(image_hsv, lower_blue, upper_blue)
rivers_bgr = cv2.bitwise_and(image, image, mask=rivers_mask)
rivers_gray = cv2.cvtColor(rivers_bgr, cv2.COLOR_BGR2GRAY)
_, rivers_alpha = cv2.threshold(rivers_gray, 0, 255, cv2.THRESH_BINARY)
rivers_b, rivers_g, rivers_r = cv2.split(rivers_bgr)
rivers_bgra = [rivers_b, rivers_g, rivers_r, rivers_alpha]
return cv2.merge(rivers_bgra, 4)
def reshape(self,blocks):
_,gImage,rImage = cv2.split(self.image)
bImage = []
for chunk in self.chunkRows(blocks,self.col/8):
for numRow in range(8):
for block in chunk:
bImage.extend(block[numRow])
bImage = np.array(bImage).reshape(self.row,self.col)
bImage = np.uint8(bImage)
img = cv2.merge((bImage,gImage,rImage))
return img
def remove_background(image):
"""
Removes background from image
"""
# Paramters.
BLUR = 21
CANNY_THRESH_1 = 10
CANNY_THRESH_2 = 30
MASK_DILATE_ITER = 10
MASK_ERODE_ITER = 10
MASK_COLOR = (0.0, 0.0, 1.0)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Edge detection.
edges = cv2.Canny(gray, CANNY_THRESH_1, CANNY_THRESH_2)
edges = cv2.dilate(edges, None)
edges = cv2.erode(edges, None)
# Find contours in edges, sort by area
contour_info = []
contours, _ = cv2.findContours(edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
for c in contours:
contour_info.append((
c,
cv2.isContourConvex(c),
cv2.contourArea(c),
))
contour_info = sorted(contour_info, key=lambda c: c[2], reverse=True)
max_contour = contour_info[0]
# Create empty mask.
mask = np.zeros(edges.shape)
cv2.fillConvexPoly(mask, max_contour[0], (255))
# Smooth mask and blur it.
mask = cv2.dilate(mask, None, iterations=MASK_DILATE_ITER)
mask = cv2.erode(mask, None, iterations=MASK_ERODE_ITER)
mask = cv2.GaussianBlur(mask, (BLUR, BLUR), 0)
mask_stack = np.dstack([mask] * 3)
# Blend masked img into MASK_COLOR background
mask_stack = mask_stack.astype('float32') / 255.0
image = image.astype('float32') / 255.0
masked = (mask_stack * image) + ((1 - mask_stack) * MASK_COLOR)
masked = (masked * 255).astype('uint8')
c_red, c_green, c_blue = cv2.split(image)
img_a = cv2.merge((c_red, c_green, c_blue, mask.astype('float32') / 255.0))
return img_a * 255
def augment_hsv(img, hgain=0.5, sgain=0.5, vgain=0.5):
r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1 # random gains
hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV))
dtype = img.dtype # uint8
x = np.arange(0, 256, dtype=np.int16)
lut_hue = ((x * r[0]) % 180).astype(dtype)
lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)
lut_val = np.clip(x * r[2], 0, 255).astype(dtype)
img_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val))).astype(dtype)
cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img) # no return needed
def adapt_hist_equilization(img):
#img = cv2.imread("test_001.jpg")
R, G, B = cv2.split(img)
output1_R = cv2.equalizeHist(R)
output1_G = cv2.equalizeHist(G)
output1_B = cv2.equalizeHist(B)
equ = cv2.merge((output1_R, output1_G, output1_B))
res = np.hstack((img, equ)) #stacking images side-by-side
return res
def _clahe_rgb(rgb_array, clip_limit=2.0, tile_grid_size=(8, 8)):
# convert RGB to LAB
lab = cv2.cvtColor(rgb_array, cv2.COLOR_RGB2LAB)
# apply clahe on LAB's L component.
lab_planes = cv2.split(lab)
clahe = cv2.createCLAHE(clipLimit=clip_limit,
tileGridSize=tile_grid_size)
lab_planes[0] = clahe.apply(lab_planes[0])
lab = cv2.merge(lab_planes)
# remap LAB tp RGB.
rgb = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
return rgb
def pre_dispose(self):#返回一个面上的颜色平均值HSVRGB
img = cv2.GaussianBlur(self.frame,(7,7),0)
b,g,r = cv2.split(img)
avgb = cv2.mean(b)[0]
avgg = cv2.mean(g)[0]
avgr = cv2.mean(r)[0]
k = (avgb+avgg+avgr)/3
kb = k/avgb
kg = k/avgg
kr = k/avgr
b = cv2.addWeighted(src1=b, alpha=kb, src2=0, beta=0, gamma=0)
g = cv2.addWeighted(src1=g, alpha=kg, src2=0, beta=0, gamma=0)
r = cv2.addWeighted(src1=r, alpha=kr, src2=0, beta=0, gamma=0)
img = cv2.merge([b,g,r])
img_hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
h,s,v = cv2.split(img_hsv)
v = cv2.equalizeHist(v)
img_hsv = cv2.merge([h,s,v])
self.img_hsv = img_hsv
img = cv2.cvtColor(img_hsv,cv2.COLOR_HSV2BGR)
self.img_bgr = img
self.frame = img
def export(img, output_path: str, size: int = 0, grayscale: bool = False):
if size > 0:
img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA)
if grayscale:
img_gray = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
_, _, _, alpha = cv2.split(img)
luminescence = img_gray[0]
img = cv2.merge((luminescence, luminescence, luminescence, alpha))
os.makedirs(os.path.dirname(output_path), exist_ok=True)
cv2.imwrite(output_path, img)
def changeBrightness(self, img, value):
""" This function will take an image (img) and the brightness
value. It will perform the brightness change using OpenCv
and after split, will merge the img and return it.
"""
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
h, s, v = cv2.split(hsv)
lim = 255 - value
v[v > lim] = 255
v[v <= lim] += value
final_hsv = cv2.merge((h, s, v))
img = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2BGR)
return img
def __init__(self,file,mode=cv2.IMREAD_COLOR):
self.file = file
try:
self.image = self.loadImg(file,mode)
except:
print("Load image error!")
print(self.image.shape)
#assert self.image != None #"Load image error!"
"""#change b g r channel order avoid color not correct when plot"""
if mode == cv2.IMREAD_COLOR:
b,g,r = cv2.split(self.image) # get b,g,r
self.image = cv2.merge([r,g,b]) # switch it to rgb
def equalized(image: np.array) -> np.array:
"""Equalizes the image using CLAHE."""
clahe = cv2.createCLAHE(clipLimit=4)
if is_colored(image):
image = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
lab_planes = cv2.split(image)
lab_planes[0] = clahe.apply(lab_planes[0])
image = cv2.merge(lab_planes)
image = cv2.cvtColor(image, cv2.COLOR_LAB2BGR)
else:
image = clahe.apply(image)
return image
