def ssr_c(img, size):
img_G = replaceZeroes(cv2.GaussianBlur(img, (size, size), 0))
img = replaceZeroes(img)
# img_G = cv2.GaussianBlur(img, (size, size), 0)
log_S = cv2.log(img / 255.0)
g_L = cv2.log(img_G / 255.0)
log_L = cv2.multiply(log_S, g_L)
log_R = cv2.subtract(log_S, log_L)
dst_R = cv2.normalize(log_R, None, 0, 255, cv2.NORM_MINMAX)
R_c = cv2.convertScaleAbs(dst_R)
return R_c
def img_calc(img1, img2, method):
if method == "add":
return cv.add(img1, img2)
elif method == "sub":
return cv.subtract(img1, img2)
elif method == "multi":
return cv.multiply(img1, img2)
elif method == "divide":
return cv.divide(img1, img2)
elif method == "and":
return cv.bitwise_and(img1, img2)
elif method == "or":
return cv.bitwise_or(img1, img2)
elif method == "not":
return cv.bitwise_not(img1, img2)
else:
return False
def PQFT(prev_img, next_img, map_size = 64):
"""
Computing saliency using phase spectrum of quaternion fourier transform.
Images are 3 channel.
"""
new_shape = (int(next_img.shape[1]/(next_img.shape[0]/map_size)), map_size)
next_img = cv2.resize(next_img, new_shape, cv2.INTER_LINEAR)
(b, g, r) = cv2.split(next_img)
# color channels
R = r-(g+b)/2
G = g-(r+b)/2
B = b-(r+g)/2
Y = (r+g)/2-abs(r-g)/2-b
red_green = R-G
blue_yellow = B-Y
# intensity
intensity = np.sum(next_img, axis=-1)
# motion
prev_img = cv2.resize(prev_img, new_shape, cv2.INTER_LINEAR)
prev_intensity = np.sum(prev_img, axis=-1)
movement = abs(intensity-prev_intensity)
planes = [
movement.astype(np.float64),
red_green.astype(np.float64),
]
f1 = cv2.merge(planes)
f1 = cv2.dft(f1)
planes = cv2.split(f1)
magnitude1 = cv2.magnitude(planes[0], planes[1])
magnitude1 = cv2.multiply(magnitude1, magnitude1)
planes = [
blue_yellow.astype(np.float64),
intensity.astype(np.float64),
]
f2 = cv2.merge(planes)
f2 = cv2.dft(f2)
planes = cv2.split(f2)
magnitude2 = cv2.magnitude(planes[0], planes[1])
magnitude2 = cv2.multiply(magnitude2, magnitude2)
magnitude = magnitude1+magnitude2
magnitude = cv2.sqrt(magnitude)
planes[0] = planes[0]/magnitude
planes[1] = planes[1]/magnitude
f2 = cv2.merge(planes)
planes = cv2.split(f1)
planes[0] = planes[0]/magnitude
planes[1] = planes[1]/magnitude
f1 = cv2.merge(planes)
cv2.dft(f1, f1, cv2.DFT_INVERSE)
cv2.dft(f2, f2, cv2.DFT_INVERSE)
planes = cv2.split(f1)
magnitude1 = cv2.magnitude(planes[0], planes[1])
magnitude1 = cv2.multiply(magnitude1, magnitude1)
planes = cv2.split(f2)
magnitude2 = cv2.magnitude(planes[0], planes[1])
magnitude2 = cv2.multiply(magnitude2, magnitude2)
magnitude = magnitude1 + magnitude2
magnitude = cv2.GaussianBlur(magnitude, (5, 5), 8, None, 8)
saliency = np.zeros((new_shape[0], new_shape[1], 1), np.uint8)
saliency = cv2.normalize(magnitude, saliency, 0,
255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
return saliency
if cv2.waitKey(25) & 0xFF == ord('Q'):
break
# Break the loop
else:
break
for i in range(0,420):
foreground = img1_array[i]
background = cv2.imread("Blending/girl.jpg")
alpha = cv2.imread("Blending/mask.png")
# Convert uint8 to float
foreground = foreground.astype(float)
background = background.astype(float)
# Normalize the alpha mask to keep intensity between 0 and 1
alpha = alpha.astype(float)/255
# Multiply the foreground with the alpha matte
foreground = cv2.multiply(alpha, foreground)
# Multiply the background with ( 1 - alpha )
background = cv2.multiply(1.0 - alpha, background)
# Add the masked foreground and background.
outImage = cv2.add(foreground, background)
# Display image
cv2.imshow("outImg", outImage/255)
print(i)
if cv2.waitKey(25) & 0xFF == ord('Q'):
break
cap.release()
# Closes all the frames
cv2.destroyAllWindows()
def multiply_demo(m1, m2): #乘法
dst = cv.multiply(m1, m2)
cv.imshow("multiply result", dst)
def multiply_demo(m1, m2): # 两张图片需要同样大
dst = cv.multiply(m1, m2)
cv.imshow("multiply_demo", dst)