def denoising_2_demo():
"""
第一个参数是一个噪声帧的列表。
第二个参数 imgtoDenoiseIndex 设定那些帧需要去噪，我们可以传入一 个帧的索引。
第三个参数 temporaWindowSize 可以设置用于去噪的相邻帧的数目，它应该是一个奇数。
在这种情况下 temporaWindowSize 帧的 图像会被用于去噪，中间的帧就是要去噪的帧。
例如，我们传入 5 帧图像， imgToDenoiseIndex = 2 和 temporalWindowSize = 3。
那么第一帧，第二帧， 第三帧图像将被用于第二帧图像的去噪
"""
capture = cv.VideoCapture("../images/vtest.avi")
image = [capture.read()[1] for i in range(5)]
gray = [cv.cvtColor(i, cv.COLOR_BGR2GRAY) for i in image]
gray = [np.float64(i) for i in gray]
noise = np.random.randn(*gray[1].shape) * 10
noisy = [i + noise for i in gray]
noisy = [np.uint8(np.clip(i, 0, 255)) for i in noisy]
# fastNlMeansDenoisingColoredMulti(srcImgs, imgToDenoiseIndex, temporalWindowSize,
# dst=None, h=None, hColor=None, templateWindowSize=None, searchWindowSize=None):
dst = cv.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 4, 7, 35)
plt.subplot(131), plt.imshow(gray[2], 'gray')
plt.subplot(132), plt.imshow(noisy[2], 'gray')
plt.subplot(133), plt.imshow(dst, 'gray')
plt.show()
def multi_denoising(self, img):
# Enhance image
img = cv2.fastNlMeansDenoisingMulti(img, imgToDenoiseIndex=2, temporalWindowSize=5, dst=None, h=1,
templateWindowSize=7, searchWindowSize=21)
cv2.imshow('image', img)
cv2.waitKey(0)
return img
def reduceNoise(images, greyScale):
if (len(images) > 1):
if greyScale == 1:
return cv.fastNlMeansDenoisingMulti(images, 0, len(images))
else:
return cv.fastNlMeansDenoisingColoredMulti(images, 1, len(images))
elif (len(images) == 1):
if greyScale == 1:
return cv.fastNlMeansDenoising(images[0], None, 10)
def fase2():
from Arduino.Arduino import Arduino
arduino = Arduino(baudrate=9600,timeout=1)
ret = arduino.setup(port= 0)
arduino.write("Is90F")
arduino.write("Im0&0F")
cap = cv2.VideoCapture(0)
#Factor para pixelar la imagen manteninendo la raelación de aspecto
factor_reescalado = 4
#Respecto al denoise multiple almacena frames anteriores
pila_denoise = []
len_pila_denoise = 3
while True:
margin = 30
in_front = 100
ret,frame = cap.read()
resized = cv2.resize(frame,(frame.shape[1]//factor_reescalado,frame.shape[0]//factor_reescalado))
resized = cv2.resize(resized,(resized.shape[1]*factor_reescalado,resized.shape[0]*factor_reescalado))
#Denoise multiple
dst = resized
pila_denoise.append(resized)
if(len(pila_denoise)>len_pila_denoise):
#https://docs.opencv.org/3.4/d1/d79/group__photo__denoise.html#ga723ffde1969430fede9241402e198151
dst = cv2.fastNlMeansDenoisingMulti(pila_denoise, len(pila_denoise)-1, (len_pila_denoise-1)//2, None, 4, 7, 5)
del pila_denoise[0]
blur = cv2.GaussianBlur(dst,(5,5),0)
gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)
edges = auto_canny(gray,sigma = 0.7)
circles = cv2.HoughCircles(edges,cv2.HOUGH_GRADIENT,1,35,
param1=50,param2=30,minRadius=0,maxRadius=edges.shape[1])
if (circles is not None):
circles = np.round(circles[0,:].astype("int"))
for i in circles:
#cv2.circle(gray,(i[0],i[1]),i[2],(0,255,0),2)
#cv2.circle(gray,(i[0],i[1]),2,(0,0,255),3)
while(check_size()<in_front):
if(i[1]>frame.shape[1]/2+margin):
arduino.move_motors(240,0)
elif(i[1]<frame.shape[1]/2-margin):
arduino.move_motors(0,240)
else:
arduino.move_motors(240,240)
sleep(0.01)
recoger()
res = np.hstack((gray,edges))
#cv2.imshow("resized",res)
cv2.imshow("dst",res)
k = cv2.waitKey(1)
if (ord('k')==k):
cv2.destroyAllWindows()
break
pass
def denoising(self, images):
# todo: need to be optimized later
# todo: can be extended to multiple images, like cv.fastNlMeansDenoisingColoredMulti
# todo: Or to run a super-resolution model,
# need to maintain another internal list/dictionary
# denoised_image = cv2.fastNlMeansDenoisingColored(image, None, 10, 10, 7, 21)
denoised_image = cv2.fastNlMeansDenoisingMulti(images, 2, 5, None, 4,
7, 35)
return denoised_image
def denoise_depth(depth_images: list, temporal_window_size=7) -> np.ndarray:
return cv2.fastNlMeansDenoisingMulti(
depth_images,
imgToDenoiseIndex=3,
temporalWindowSize=temporal_window_size,
dst=None,
templateWindowSize=7,
searchWindowSize=21,
# normType=NORM_L1
)
def denoising_video_grayscale(itdi, sq, vid, fs, tps, ws, tws):
for i in range(itdi):
sq.append(cv2.fastNlMeansDenoising(vid[i], None, fs, tps, ws))
for k in range(len(vid) - itdi * 2):
l_tws = [vid[k + 1] for i in range(tws)]
sq.append(
cv2.fastNlMeansDenoisingMulti(l_tws, itdi, tws, None, fs, tps, ws))
for i in range(itdi):
sq.append(
cv2.fastNlMeansDenoising(vid[len(vid) - itdi + i], None, fs, tps,
ws))
def apply_denoising(img): # create a list of first 5 frames #img = [cap.read()[1] for i in xrange(5)] # convert all to grayscale gray = [cv2.cvtColor(i, cv2.COLOR_BGR2GRAY) for i in img] # convert all to float64 #gray = [np.float64(i) for i in gray] # create a noise of variance 25 #noise = np.random.randn(*gray[1].shape)*10 # Add this noise to images #noisy = [i+noise for i in gray] # Convert back to uint8 #noisy = [np.uint8(np.clip(i,0,255)) for i in noisy] # Denoise 3rd frame considering all the 5 frames dst = cv2.fastNlMeansDenoisingMulti(gray, 1, 3, None, 4, 7, 35) return dst
def denoise_video(self):
cap = cv2.VideoCapture('../images/vtest.avi')
img = [cap.read()[1] for i in range(5)]# 创建一个前5帧的list
gray = [cv2.cvtColor(i, cv2.COLOR_BGR2GRAY) for i in img]# 全部转为灰度图
gray = [np.float64(i) for i in gray]# 全部转为float64类型
noise = np.random.randn(*gray[1].shape) * 10#创建一个方差为25的噪声
noisy = [i + noise for i in gray]#向所有图像添加噪声
noisy = [np.uint8(np.clip(i, 0, 255)) for i in noisy]#转为uint8类型
# 根据这5帧图像，对第三帧去噪
dst = cv2.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 4, 7, 35)
titles = ['3rd frame', '3rd frame+noise','3rd denoise']
imgs = [gray[2], noisy[2],dst]
for i in range(3):
plt.subplot(1, 3, i + 1), plt.imshow(imgs[i], 'gray')
plt.title(titles[i])
plt.xticks([]), plt.yticks([])
plt.show()
def fase2():
cap = cv2.VideoCapture(0)
#Factor para pixelar la imagen manteninendo la raelación de aspecto
factor_reescalado = 4
#Respecto al denoise multiple almacena frames anteriores
pila_denoise = []
len_pila_denoise = 3
while True:
ret,frame = cap.read()
resized = cv2.resize(frame,(frame.shape[1]//factor_reescalado,frame.shape[0]//factor_reescalado))
resized = cv2.resize(resized,(resized.shape[1]*factor_reescalado,resized.shape[0]*factor_reescalado))
#Denoise multiple
dst = resized
pila_denoise.append(resized)
if(len(pila_denoise)>len_pila_denoise):
#https://docs.opencv.org/3.4/d1/d79/group__photo__denoise.html#ga723ffde1969430fede9241402e198151
dst = cv2.fastNlMeansDenoisingMulti(pila_denoise, len(pila_denoise)-1, (len_pila_denoise-1)//2, None, 4, 7, 5)
del pila_denoise[0]
blur = cv2.GaussianBlur(dst,(5,5),0)
gray = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)
edges = auto_canny(gray,sigma = 0.7)
###################
circles = cv2.HoughCircles(edges,cv2.HOUGH_GRADIENT,1,35,
param1=50,param2=30,minRadius=0,maxRadius=edges.shape[1])
if (circles is not None):
circles = np.round(circles[0,:].astype("int"))
for i in circles:
# draw the outer circle
cv2.circle(gray,(i[0],i[1]),i[2],(0,255,0),2)
# draw the center of the circle
cv2.circle(gray,(i[0],i[1]),2,(0,0,255),3)
res = np.hstack((gray,edges))
#cv2.imshow("resized",res)
cv2.imshow("dst",res)
k = cv2.waitKey(1)
if (ord('k')==k):
cv2.destroyAllWindows()
break
pass
def denoise(source: str, destination: str) -> None:
vid = _cv.VideoCapture(source)
# (t,y,x,chan)
color_movie = _get_frames(vid)
temporal_win_size = _cfg.denoise.temporal_window_size
strength = _cfg.denoise.strength
template_win_size = _cfg.denoise.template_window_size
search_win_size = _cfg.denoise.search_window_size
print("Denoising...")
# (t,y,x,chan)
denoised_color_movie = _np.zeros(color_movie.shape,
color_movie.dtype) # type: ignore
for index in range(color_movie.shape[0]):
print(f" {index + 1: 5}/{color_movie.shape[0]}\u000D", end="")
if (index < temporal_win_size // 2 or
(color_movie.shape[0] - 1) - index < temporal_win_size // 2):
denoised_color_movie[index] = color_movie[index]
continue
denoised_color_movie[index] = _cv.fastNlMeansDenoisingMulti(
color_movie,
index,
temporal_win_size,
h=strength,
templateWindowSize=template_win_size,
searchWindowSize=search_win_size,
)
else:
print("")
# Save results
_matrix_to_video(
denoised_color_movie,
destination,
"mp4v",
vid.get(_cv.CAP_PROP_FPS),
int(vid.get(_cv.CAP_PROP_FRAME_WIDTH)),
int(vid.get(_cv.CAP_PROP_FRAME_HEIGHT)),
)
vid.release()
def test_4912(self):
cap = cv2.VideoCapture('vtest.avi')
# create a list of first 5 frames
img = [cap.read()[1] for i in range(5)]
# convert all to grayscale
gray = [cv2.cvtColor(i, cv2.COLOR_BGR2GRAY) for i in img]
# convert all to float64
gray = [np.float64(i) for i in gray]
# create a noise of variance 25
noise = np.random.randn(*gray[1].shape) * 10
# Add this noise to images
noisy = [i + noise for i in gray]
# Convert back to uint8
noisy = [np.uint8(np.clip(i, 0, 255)) for i in noisy]
# Denoise 3rd frame considering all the 5 frames
dst = cv2.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 4, 7, 35)
plt.subplot(131), plt.imshow(gray[2], 'gray')
plt.subplot(132), plt.imshow(noisy[2], 'gray')
plt.subplot(133), plt.imshow(dst, 'gray')
plt.show()
print("")
import numpy as np
import cv2
from matplotlib import pyplot as plt
cap = cv2.VideoCapture('multi_ants.mov')
# create a list of first 5 frames
img = [cap.read()[1] for i in range(5)]
# convert all to grayscale
gray = [cv2.cvtColor(i, cv2.COLOR_BGR2GRAY) for i in img]
# convert all to float64
gray = [np.float64(i) for i in gray]
# create a noise of variance 25
noise = np.random.randn(*gray[1].shape) * 10
# Add this noise to images
noisy = [i + noise for i in gray]
# Convert back to uint8
noisy = [np.uint8(np.clip(i, 0, 255)) for i in noisy]
# Denoise 3rd frame considering all the 5 frames
dst = cv2.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 4, 7, 35)
while (1):
ret
def main():
allContoursWithData = [] # declare empty lists,
validContoursWithData = [] # we will fill these shortly
try:
npaClassifications = np.loadtxt("classifications.txt", np.float32) # read in training classifications
# print "lOADED CLASSIFICATIONS"
except:
print "error, unable to open classifications.txt, exiting program\n"
os.system("pause")
return
# end try
try:
npaFlattenedImages = np.loadtxt("flattened_images.txt", np.float32) # read in training images
except:
print "error, unable to open flattened_images.txt, exiting program\n"
os.system("pause")
return
# end try
npaClassifications = npaClassifications.reshape((npaClassifications.size, 1)) # reshape numpy array to 1d, necessary to pass to call to train
kNearest = cv2.ml.KNearest_create() # instantiate KNN object
kNearest.train(npaFlattenedImages, cv2.ml.ROW_SAMPLE, npaClassifications)
imgTestingNumbers = cv2.imread(sys.argv[1]) # read in testing numbers image
if imgTestingNumbers is None: # if image was not read successfully
print "error: image not read from file \n\n" # print error message to std out
os.system("pause") # pause so user can see error message
return # and exit function (which exits program)
# end if
imgGray = cv2.cvtColor(imgTestingNumbers, cv2.COLOR_BGR2GRAY) # get grayscale image
# cv2.imshow("imgGray", imgGray)
imgBlurred = cv2.GaussianBlur(imgGray, (5,5), 0) # blur
#cv2.imshow("imgBlurred", imgBlurred)
# filter image from grayscale to black and white
imgThresh = cv2.adaptiveThreshold(imgBlurred, # input image
255, # make pixels that pass the threshold full white
cv2.ADAPTIVE_THRESH_GAUSSIAN_C, # use gaussian rather than mean, seems to give better results
cv2.THRESH_BINARY_INV, # invert so foreground will be white, background will be black
11, # size of a pixel neighborhood used to calculate threshold value
2) # constant subtracted from the mean or weighted mean
imgThreshCopy = imgThresh.copy() # make a copy of the thresh image, this in necessary b/c findContours modifies the image
noNoise = cv2.fastNlMeansDenoisingMulti(imgBlurred, 2, 5, None, 4, 7 , 35)
# cv2.imshow("test", noNoise)
# cv2.imshow("imgThreshCopy", imgThreshCopy)
imgContours, npaContours, npaHierarchy = cv2.findContours(imgThreshCopy, # input image, make sure to use a copy since the function will modify this image in the course of finding contours
cv2.RETR_EXTERNAL, # retrieve the outermost contours only
cv2.CHAIN_APPROX_SIMPLE) # compress horizontal, vertical, and diagonal segments and leave only their end points
for npaContour in npaContours: # for each contour
contourWithData = ContourWithData() # instantiate a contour with data object
contourWithData.npaContour = npaContour # assign contour to contour with data
contourWithData.boundingRect = cv2.boundingRect(contourWithData.npaContour) # get the bounding rect
contourWithData.calculateRectTopLeftPointAndWidthAndHeight() # get bounding rect info
contourWithData.fltArea = cv2.contourArea(contourWithData.npaContour) # calculate the contour area
allContoursWithData.append(contourWithData) # add contour with data object to list of all contours with data
# end for
for contourWithData in allContoursWithData: # for all contours
if contourWithData.checkIfContourIsValid(): # check if valid
validContoursWithData.append(contourWithData) # if so, append to valid contour list
# end if
# end for
validContoursWithData.sort(key = operator.attrgetter("intRectX")) # sort contours from left to right
strFinalString = "" # declare final string, this will have the final number sequence by the end of the program
for contourWithData in validContoursWithData: # for each contour
# draw a green rect around the current char
cv2.rectangle(imgTestingNumbers, # draw rectangle on original testing image
(contourWithData.intRectX, contourWithData.intRectY), # upper left corner
(contourWithData.intRectX + contourWithData.intRectWidth, contourWithData.intRectY + contourWithData.intRectHeight), # lower right corner
(0, 255, 0), # green
2) # thickness
imgROI = imgThresh[contourWithData.intRectY : contourWithData.intRectY + contourWithData.intRectHeight, # crop char out of threshold image
contourWithData.intRectX : contourWithData.intRectX + contourWithData.intRectWidth]
imgROIResized = cv2.resize(imgROI, (RESIZED_IMAGE_WIDTH, RESIZED_IMAGE_HEIGHT)) # resize image, this will be more consistent for recognition and storage
npaROIResized = imgROIResized.reshape((1, RESIZED_IMAGE_WIDTH * RESIZED_IMAGE_HEIGHT)) # flatten image into 1d numpy array
npaROIResized = np.float32(npaROIResized) # convert from 1d numpy array of ints to 1d numpy array of floats
retval, npaResults, neigh_resp, dists = kNearest.findNearest(npaROIResized, k = 1) # call KNN function find_nearest
strCurrentChar = str(chr(int(npaResults[0][0]))) # get character from results
strFinalString = strFinalString + strCurrentChar # append current char to full string
# end for
print "\n" + strFinalString + "\n" # show the full string
file = open(sys.argv[2],"w")
file.write(strFinalString)
file.close()
# cv2.imshow("imgTestingNumbers", imgTestingNumbers) # show input image with green boxes drawn around found digits
cv2.waitKey(0) # wait for user key press
cv2.destroyAllWindows() # remove windows from memory
return
def _video_smoothing(le_data_dir,
div,
save_dir,
raw_video_fpath,
smoothing_method="avg_diff"):
fname = osp.splitext(osp.basename(raw_video_fpath))[0]
label = raw_video_fpath.split(os.sep)[-2]
raw_frame_list = read_video(raw_video_fpath)
le_frame_list = read_video(
osp.join(le_data_dir, div, label, f"{fname}.avi"))
if smoothing_method == "avg_diff":
weight = [1 / 5, 1 / 5, 1 / 5, 1 / 5, 1 / 5]
# get difference frame between raw and le
diff_frame_list = []
for raw, le in zip(raw_frame_list, le_frame_list):
raw = raw.astype(np.float32)
le = le.astype(np.float32)
diff_frame = raw - le
diff_frame_list.append(diff_frame)
# get smoothed le
smooth_frame_list = []
for i, raw in enumerate(raw_frame_list):
smooth = []
for j, w in enumerate(weight):
# handling overflow
idx = i + j - int(len(weight) / 2)
idx = np.clip(idx, 0, len(diff_frame_list) - 1)
smooth.append(w * diff_frame_list[idx])
smooth = np.stack(smooth)
smooth = np.sum(smooth, axis=0)
le = raw.astype(np.float32) - smooth
le = np.clip(le, 0, 255)
le = le.astype(np.uint8)
smooth_frame_list.append(le)
elif smoothing_method == "denoising":
num_frame = 5
smooth_frame_list = []
for i, raw in enumerate(le_frame_list):
smooth = []
for j in range(num_frame):
# handling overflow
idx = i + j - int(num_frame / 2)
idx = np.clip(idx, 0, len(le_frame_list) - 1)
smooth.append(le_frame_list[idx])
smooth = cv2.fastNlMeansDenoisingMulti(smooth, 2, 5, None, 4, 7,
35)
smooth_frame_list.append(smooth)
# save results
if not osp.isdir(osp.join(save_dir, div, label)):
os.makedirs(osp.join(save_dir, div, label))
save_video(smooth_frame_list, osp.join(save_dir, div, label,
f"{fname}.avi"))
import numpy as np
import cv2
import time
cap = cv2.VideoCapture('hallsmooth17.mp4')
#think about setting the frame height and width before the processing
out = cv2.VideoWriter('output4.avi',cv2.cv.CV_FOURCC('M','J','P','G'), 20.0, (360,288))
while(True):
ret, frame = cap.read()
median = cv2.medianBlur(frame,5)
dst = cv2.fastNlMeansDenoisingMulti(median, 2, 5, None, 4, 7, 35)
cv2.imshow('frame',dst)
out.write(dst)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
# create a list of first 5 frames
frame = [cap.read()[1] for i in range(5)]
# convert all to grayscale
gray = [cv.cvtColor(i, cv.COLOR_BGR2GRAY) for i in frame]
# convert all to float64
gray = [np.float64(i) for i in gray]
# create a noise of variance 25
noise = np.random.randn(*gray[1].shape) * 10
# Add this noise to images
noisy = [i + noise for i in gray]
# Convert back to uint8
noisy = [np.uint8(np.clip(i, 0, 255)) for i in noisy]
# Denoise 3rd frame considering all the 5 frames
ret_frame = cv.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 4, 7, 35)
# show
images = [img, ret_img, gray[2], noisy[2], ret_frame]
colors = ['gray', 'gray', 'gray', 'gray', 'gray']
titles = ["img", "ret_img", "gray", "noisy", "ret_frame"]
for i in range(len(images)):
plt.subplot(2, 3, i + 1)
plt.imshow(images[i], colors[i])
plt.title(titles[i])
plt.show()
from matplotlib import pyplot as plt
cap = cv2.VideoCapture(0)
while (1):
img = [cap.read()[1] for i in xrange(5)]
gray = [cv2.cvtColor(i, cv2.COLOR_BGR2GRAY) for i in img]
gray = [np.float64(i) for i in gray]
noise = np.random.randn(*gray[1].shape) * 10
noisy = [i + noise for i in gray]
noisy = [np.uint8(np.clip(i, 0, 255)) for i in noisy]
dst = cv2.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 4, 7, 35)
plt.subplot(131), plt.imshow(gray[2], 'gray')
plt.subplot(132), plt.imshow(noisy[2], 'gray')
plt.subplot(133), plt.imshow(dst, 'gray')
plt.show()
k = cv2.waitKey(5) & 0xFF
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
import numpy as np
import cv2
a = []
a.append(cv2.imread("data/a1.jpg"))
a.append(cv2.imread("data/a2.jpg"))
a.append(cv2.imread("data/a3.jpg"))
a.append(cv2.imread("data/a4.jpg"))
a.append(cv2.imread("data/a5.jpg"))
a.append(cv2.imread("data/a6.jpg"))
a.append(cv2.imread("data/a7.jpg"))
a.append(cv2.imread("data/a8.jpg"))
a.append(cv2.imread("data/a9.jpg"))
gray = [cv2.cvtColor(i, cv2.COLOR_BGR2GRAY) for i in a]
# Convert back to uint8
gray = [np.uint8(np.clip(i,0,255)) for i in gray]
# Denoise 3rd frame considering all the 5 frames
dst = cv2.fastNlMeansDenoisingMulti(gray, 4, 9, None, 3, 7, 21)
cv2.imshow("noise reduction", dst)
cv2.waitKey(0)
import numpy as np
import cv2
import time
cap = cv2.VideoCapture('hallsmooth17.mp4')
#think about setting the frame height and width before the processing
out = cv2.VideoWriter('output4.avi', cv2.cv.CV_FOURCC('M', 'J', 'P', 'G'),
20.0, (360, 288))
while (True):
ret, frame = cap.read()
median = cv2.medianBlur(frame, 5)
dst = cv2.fastNlMeansDenoisingMulti(median, 2, 5, None, 4, 7, 35)
cv2.imshow('frame', dst)
out.write(dst)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
import cv2
import numpy as np
import time
'''
your computer will be destroyed
camera extracting beautiful out of series of image
'''
cap = cv2.VideoCapture(0)
ret, frame = cap.read()
time.sleep(2)
while True:
image_list = []
for i in range(5):
ret, frame = cap.read()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
frame = cv2.flip(frame, 180)
image_list.append(frame)
#name = chr(97 + i) + '.png'
#cv2.imwrite(name,frame)
dst = cv2.fastNlMeansDenoisingMulti(image_list, 2, 5, None, 4, 7, 35)
cv2.imshow('destination', dst)
#type q to get out
if cv2.waitKey(1) & 0xFF == ord('q'):
break
#cv2.imwrite('result.png',dst)
cap.release()
cv2.destroyAllWindows()
kernel_5x5 = np.ones((5,5) , np.float32) / 25
kernel_7x7 = np.ones((7,7) , no.float32) / 49
#Blur - Convolotion
blurred = cv2.filter2D(image, -1, kernel_3x3)
#Blur - Averaged
blured_box = cv2.blur(image, (3,3))
#Blur - Gaussian
blurred_gauss = cv2.GaussianBlur(image, (7,7), 0)
#Blur Median
blurred_median = cv2.medianBlur(image, 5) #Painted type effect
#Blur - Bilateral
blurred_bileteral = cv2.bilateralFilter(image, 9, 75, 75) #Very effective noise but keeps edges sharp
#Image Denoising
#Nonlocal Means Denoising (Cleaning noise and making image more DSLR)
dst = cv2.fastNlMeansDenoisingColored(image, None, 6, 6, 7, 21) # For color image
cv2.fastNlMeansDenoising() # Works with single grayscale image
cv2.fastNlMeansDenoisingMulti() # works with image sequence captured in short period of time (grayscale)
cv2.fastNlMeansDenoisingColoredMulti() # works with image sequence captured in short period of time (color)
#Sharpening
|-1 -1 -1|
|-1 +9 -1| #Sum is 1 so don't need to normalization
|-1 -1 -1|
def denoise(imgs):
return (cv.fastNlMeansDenoisingMulti(imgs, 2, 5, None, h,
templateWindowSize,
searchWindowPixel))
cv2.waitKey(0)
"""
Python: cv2.fastNlMeansDenoisingMulti(srcImgs, imgToDenoiseIndex, temporalWindowSize[, dst[, h[, templateWindowSize[, searchWindowSize]]]]) -> dst
Parameters:
srcImgs – Input 8-bit 1-channel, 2-channel or 3-channel images sequence. All images
should have the same type and size.
imgToDenoiseIndex – Target image to denoise index in srcImgs sequence
temporalWindowSize – Number of surrounding images to use for target image denoising.
Should be odd.
Images from imgToDenoiseIndex - temporalWindowSize / 2 to imgToDenoiseIndex - temporalWindowSize / 2
from srcImgs will be used to denoise srcImgs[imgToDenoiseIndex] image.
dst – Output image with the same size and type as srcImgs images.
templateWindowSize – Size in pixels of the template patch that is used to compute weights.
Should be odd. Recommended value 7 pixels
searchWindowSize – Size in pixels of the window that is used to compute weighted average
for given pixel. Should be odd. Affect performance linearly:
greater searchWindowsSize - greater denoising time. Recommended value 21 pixels
h – Parameter regulating filter strength for luminance component. Bigger h value perfectly
removes noise but also removes image details, smaller h value preserves details but also
preserves some noise
"""
dst2 = cv2.fastNlMeansDenoisingMulti([gray], 0, 1, None, 6, 7, 21)
cv2.imshow('Fast Means Denoising Multi', dst2)
cv2.waitKey(0)
dst3 = cv2.fastNlMeansDenoisingColoredMulti([image], 0, 1, None, 6, 6, 7, 21)
cv2.imshow('Fast Means Denoising Multi (color)', dst3)
cv2.waitKey(0)
cv2.destroyAllWindows()
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('/home/qiao/PythonProjects/Opencv_On_CT/Test_Img/10.jpg', 0)
dst = cv.fastNlMeansDenoisingMulti(img, 2, 5, None, 4, 7, 35)
plt.subplot(121), plt.imshow(img)
plt.subplot(122), plt.imshow(dst)
plt.show()
彩色图像算法 fastNlMeansDenoisingColored(src[, dst[, h[, hColor[, templateWindowSize[, searchWindowSize]]]]]) -> dst h=3, hColor=3, tempWindow=7, searchWindow=21 推荐参数 噪声 ∂ 块大小 s 搜索窗口 衰减参数 h 0< ∂ =<25 |3 x 3 |21 x 21 |0.55 * ∂ | 25< ∂ =<55 |5 x 5 |35 x 35 |0.40 * ∂ | 55< ∂ =<100 |7 x 7 |35 x 35 |0.35 * ∂ | """ color = cv2.fastNlMeansDenoisingColored(img) """ 适用于顺序帧序列的去噪声方法 1. fastNlMeansDenoisingMulti(srcImgs, imgToDenoiseIndex, temporalWindowSize[, dst[, h[, templateWindowSize[, searchWindowSize]]]]) -> dst 2. fastNlMeansDenoisingColoredMulti(srcImgs, imgToDenoiseIndex, temporalWindowSize[, dst[, h[, hColor[, templateWindowSize[, searchWindowSize]]]]]) -> dst """ denoising = cv2.fastNlMeansDenoisingMulti() denoising = cv2.fastNlMeansDenoisingColoredMulti() """ 直方图均衡化处理 需要注意的是源图必须是 8bit一维图像，所以彩色图像必须分通道处理 """ Hist = cv2.equalizeHist(img)
def filter_block(info, inputs, outputs, otherargs):
# print('Current block is')
# print(info.getBlockCount())
# print('out of')
# print(info.getTotalBlocks())
if not otherargs.filter in ['NLM', 'median', 'mean']:
raise SyntaxError(otherargs.filter +
' is not a valid filter. Use NLM, median, or mean')
if (otherargs.window_size % 2) == 0:
raise SyntaxError('window size must be an odd integer')
if not 0 <= otherargs.cc_thresh < 1:
raise SyntaxError('correlation threshold must be >=0 and <1')
if otherargs.mask:
if len(inputs.offsets) == inputs.cc:
raise SyntaxError(
'if mask=True the length of the input lists must be identical')
if otherargs.filter == 'NLM':
nlm_h = otherargs.nlm_h
nlm_search_size = otherargs.nlm_search_size
filter = otherargs.filter
window_size = otherargs.window_size
px_block = inputs.offsets
forward_list = otherargs.forward_list
# DEBUG
# from rios.imagereader import ImageReader
# from rios.readerinfo import ReaderInfo
# reader = ImageReader(inputs.offsets, overlap=otherargs.window_size, windowxsize=block_size, windowysize=block_size)
# px_block = reader.readBlock(0)
# block_coordinates_x, block_coordinates_y = px_block[0].getBlockCoordArrays()
# px_block = px_block[1]
# print(block_coordinates_x[0,0])
# print(block_coordinates_y[0,0])
# masking if requested
if otherargs.mask:
cc_block = inputs.cc
# DEBUG
# reader = ImageReader(inputs.cc, overlap=otherargs.window_size, windowxsize=block_size, windowysize=block_size)
# cc_block = reader.readBlock(0)
# cc_block = cc_block[1]
# print('This is cc_block')
# print(cc_block)
# print(len(cc_block))
cc_thresh_real = otherargs.cc_thresh * 128 + 127
cc_bool = []
for cc_patch in cc_block:
# print('Shape of cc_patch is..')
# print(cc_patch.shape)
cc_patch = cc_patch[0]
cc_bool.append(cc_patch < cc_thresh_real)
# print('This is cc_bool is..')
# print(cc_bool)
# print(len(cc_bool))
px_patch_masked = []
for px_patch, cc_patch, forward in zip(px_block, cc_bool,
forward_list):
# print('Shape of px_patch is..')
# print(px_patch.shape)
px_patch = px_patch[0] * forward
px_patch = np.ma.masked_array(px_patch, mask=cc_patch)
px_patch_masked.append(
np.ma.masked_where(
np.absolute(px_patch) > abs(otherargs.max_displacement),
px_patch))
else:
px_patch_masked = []
for px_patch, forward in zip(px_block, forward_list):
px_patch = px_patch[0] * forward
px_patch_masked.append(px_patch)
# plt.imshow(cc_patch)
# plt.imshow(cc_bool[1])
# plt.imshow(px_patch_masked[1])
if filter == 'median' or filter == 'mean':
px_patch_stack = np.ma.dstack(px_patch_masked)
# print(px_patch_stack.dtype)
if otherargs.mask:
px_patch_stack = px_patch_stack.filled(np.nan)
# print('Shape of px_patch_stack is..')
# print(px_patch_stack.shape)
w, h, d = px_patch_stack.shape
# array_mask = image.mask
strided_image = np.lib.stride_tricks.as_strided(
px_patch_stack,
shape=[
w - window_size + 1, h - window_size + 1, 1, window_size,
window_size, d
],
strides=px_patch_stack.strides + px_patch_stack.strides)
strided_image = np.squeeze(strided_image)
# print('Shape of strided stack is..')
# print(strided_image.shape)
if filter == 'median':
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=RuntimeWarning)
average_image = np.nanmedian(strided_image, axis=(2, 3, 4))
if filter == 'mean':
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=RuntimeWarning)
average_image = np.nanmean(strided_image, axis=(2, 3, 4))
# padding to get shape expected by the rios writer
average_image = np.lib.pad(average_image,
int((window_size - 1) / 2),
'constant',
constant_values=0)
# plt.imshow(average_image)
average_image = np.expand_dims(average_image, axis=0)
# print('Shape of average_image is..')
# print(average_image.shape)
if filter == 'NLM':
# stretch input to 0,255 range required by the OpenCV implementation
min_max = [
func(l) for l in px_patch_masked for func in (np.min, np.max)
]
min_px1 = np.min(min_max)
max_px1 = np.max(min_max)
noisy = [(px1_patch - min_px1) / (max_px1 - min_px1) * 255
for px1_patch in px_patch_masked]
noisy = [np.uint8(i) for i in noisy]
# fig, axs = plt.subplots(3,3)
# for ax, image in zip(axs.reshape(-1), noisy):
# ax = ax.imshow(image, vmin=0, vmax=255)
# Denoise with NLM
target_img = int(len(noisy) / 2)
temp_window = (len(noisy) - target_img) // 2 * 2 + 1
average_image = cv2.fastNlMeansDenoisingMulti(noisy, target_img,
temp_window, None, nlm_h,
window_size,
nlm_search_size)
# convert to pixel
average_image = average_image / 255 * (max_px1 - min_px1) + min_px1
# fig, axs = plt.subplots(1,2)
# axs[0].imshow(average_image, vmin=-2, vmax=2)
# axs[1].imshow(px_block[1][0][0, :, :], vmin=-2, vmax=2)
# np.array_equal(px1_median_filtered[ :, :, 0], px1_median_filtered[ :, :, 1])
# plt.imshow(px1_median_filtered[ :, :, 0] - px1_median_filtered[ :, :, 1])
#
#
# fig, axs = plt.subplots(2,3)
# axs[0,0].imshow(px1_median_filtered[ :, :, 0], vmin=-2, vmax=2)
# axs[0,0].set_title("Median filter 21*21")
# axs[0,1].imshow(px1_median_filtered[ :, :, 1], vmin=-2, vmax=2)
# axs[0,1].set_title("Median filter 21*21")
# axs[0,2].imshow(px1_median_filtered[ :, :, 6], vmin=-2, vmax=2)
# axs[0,2].set_title("Median filter 21*21")
# axs[1,0].imshow(px1_block[1][0][0, :, :], vmin=-2, vmax=2)
# axs[1,0].set_title("Input")
# axs[1,1].imshow(px1_denoised, vmin=-2, vmax=2)
# axs[1,1].set_title("NLM_seq 3, 31, 51")
# axs[1,2].imshow(px1_median_filtered_mean, vmin=-2, vmax=2)
# axs[1,2].set_title("Median of the medians")
# plt.close('all')
if otherargs.numpy_outtype:
average_image = average_image.astype(otherargs.numpy_outtype)
outputs.outimage = average_image
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
cap = cv.VideoCapture("../img/vtest.avi")
# a list of first 5 frames
img = [cap.read()[1][:200, :200] for _ in range(5)]
grayed = [cv.cvtColor(i, cv.COLOR_BGR2GRAY) for i in img]
gray = [np.float64(i) for i in grayed]
noise = np.random.randn(
*gray[1].shape) * 10 # gray[1].shape=(576, 768), *gray[1].shape=576, 768
noisy = [i + noise for i in gray]
noisy = [np.uint8(np.clip(i, 0, 255)) for i in noisy]
# the second argument means which frame we need to denoise
# the third argument means how many nearby images we use to help denoise
dst = cv.fastNlMeansDenoisingMulti(noisy, 2, 5, None, 6, 11, 35)
result = np.vstack((grayed[2], noisy[2], dst))
plt.imshow(result, cmap='gray')
plt.show()
plt.xticks([]), plt.yticks([])
cap.release()
kernel2 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (45, 45))
kernel2 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (40, 40))
if camera.isOpened():
grabbed, firstframe = camera.read()
else:
grabbed = False
while grabbed:
grabbed, frame = camera.read()
frame = imutils.resize(frame, width=500)
imgs = [camera.read()[1] for i in range(5)]
imgs = [imutils.resize(img, width=500) for img in imgs]
grays = [cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for img in imgs]
fgmasks = [fgbg.apply(gray) for gray in grays]
fgmask = cv2.fastNlMeansDenoisingMulti(fgmasks, 2, 5, None, 4, 7, 15)
output2 = fgmask
fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_CLOSE, kernel2)
output3 = fgmask
fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_OPEN, kernel1)
output4 = fgmask
fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_CLOSE, kernel2)
fgmask = cv2.bilateralFilter(fgmask, 10, 75, 75)
output5 = fgmask
contours = cv2.findContours(fgmask, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)[-2]
rects = [cv2.boundingRect(cnt) for cnt in contours]
for r in rects:
x, y, w, h = r
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 255, 0), 2)
def denoising(cls, img):
img = cls.gray(img)
return cv2.fastNlMeansDenoisingMulti(img, 2, 5, None, 4, 7, 35)
def denoise1(imgs):
img = cv2.fastNlMeansDenoisingMulti(imgs, 8, 1)
return img
import numpy as np
import cv2
import time
cap = cv2.VideoCapture('hallsmooth17.mp4')
#think about setting the frame height and width before the processing
out = cv2.VideoWriter('output4.avi',cv2.cv.CV_FOURCC('M','J','P','G'), 20.0, (360,288))
while(True):
ret, frame = cap.read()
#blank_image=cv2.pyrDown(frame)
#blank_image=cv2.bilateralFilter(frame,9,75,75)
#gray_image = cv2.cvtColor(blank_image, cv2.COLOR_BGR2GRAY)
dst = cv2.fastNlMeansDenoisingMulti(frame, 2, 5, None, 4, 7, 35)
cv2.imshow('frame',frame)
#out.write(blank_image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
import numpy as np
import cv2
import time
cap = cv2.VideoCapture('hallsmooth17.mp4')
#think about setting the frame height and width before the processing
out = cv2.VideoWriter('output4.avi', cv2.cv.CV_FOURCC('M', 'J', 'P', 'G'),
20.0, (360, 288))
while (True):
ret, frame = cap.read()
#blank_image=cv2.pyrDown(frame)
#blank_image=cv2.bilateralFilter(frame,9,75,75)
#gray_image = cv2.cvtColor(blank_image, cv2.COLOR_BGR2GRAY)
dst = cv2.fastNlMeansDenoisingMulti(frame, 2, 5, None, 4, 7, 35)
cv2.imshow('frame', frame)
#out.write(blank_image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
def ImproveData(PathToFile, Pb, Pb2):
cap = cv2.VideoCapture(PathToFile)
videoName = os.path.basename(root.filename)
videoName = videoName[:-4]
img = []
try:
if not os.path.exists(videoName):
os.makedirs(videoName + '/OriginalData')
os.makedirs(videoName + '/DenoiseData')
os.makedirs(videoName + '/ImageBordersData')
os.makedirs(videoName + '/FinalData')
except OSError:
print('Error: Creating directory of data')
currentFrame = 0
T = bool(1)
while (T):
# Capture frame-by-frame
ret, frame = cap.read()
# Saves image of the current frame in png file
name = './' + videoName + '/OriginalData/frame' + str(
currentFrame) + '.png'
# name = './OriginalData/frame' + str(currentFrame) + '.png'
cv2.imwrite(name, frame)
if os.path.getsize(name) == 0:
T = bool(0) # To stop duplicate images
os.remove(name)
else:
currentFrame += 1
img.append(frame)
CountOfImages = currentFrame - 1
# Denoising
st = (1 / (CountOfImages - 4) * 100)
for i in range(2, CountOfImages - 1):
dst = cv2.fastNlMeansDenoisingMulti(img, i, 5, None, 4, 7, 35)
#name = './DenoiseData/DenoisedFrame' + str(i) + '.png'
name = './' + videoName + '/DenoiseData/DenoisedFrame' + str(
i) + '.png'
cv2.imwrite(name, dst)
pb.step(st)
pb.update()
# Detection of borders in image
Dic_of_Pixel = {}
Original_Image = Image.open('./' + videoName +
'/DenoiseData/DenoisedFrame5.png')
global width, height
width, height = Original_Image.size
kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
for k in range(2, CountOfImages - 1):
name = './' + videoName + '/DenoiseData/DenoisedFrame' + str(
k) + '.png'
nameBorder = './' + videoName + '/ImageBordersData/BorderFrame' + str(
k) + '.png'
Grad(name, nameBorder, Dic_of_Pixel)
nameFinal = './' + videoName + '/FinalData/FinalFrame' + str(
k) + '.png'
# Sharpen of image
Sharpened(name, nameFinal, Dic_of_Pixel, kernel)
Dic_of_Pixel.clear()
pb2.step(st)
pb2.update()
# Creat video (in .mov and .mp4 format) from images in FinalData, DenoiseData, ImageBordersData
image_folder = './' + videoName + '/FinalData/'
video_name = './' + videoName + '/DenoisedVideoFinalData.mov'
video_name2 = './' + videoName + '/DenoisedVideoFinalData.mp4'
image_folderDen = './' + videoName + '/DenoiseData/'
video_nameDen = './' + videoName + '/DenoisedVideoDenoisedData.mov'
video_nameDen2 = './' + videoName + '/DenoisedVideoDenoisedData.mp4'
image_folderBor = './' + videoName + '/ImageBordersData/'
video_nameBor = './' + videoName + '/BordersVideo.mov'
video_nameBor2 = './' + videoName + '/BordersVideo.mp4'
images = [img for img in os.listdir(image_folder) if img.endswith(".png")]
imagesDen = [
img for img in os.listdir(image_folderDen) if img.endswith(".png")
]
imagesBor = [
img for img in os.listdir(image_folderBor) if img.endswith(".png")
]
imag = []
imagDen = []
imagBor = []
for i in range(2, CountOfImages - 1):
imag.append('FinalFrame' + str(i) + '.png')
imagDen.append('DenoisedFrame' + str(i) + '.png')
imagBor.append('BorderFrame' + str(i) + '.png')
frame = cv2.imread(os.path.join(image_folder, images[0]))
height, width, layers = frame.shape
video = cv2.VideoWriter(video_name, -1, cap.get(cv2.CAP_PROP_FPS),
(width, height))
video2 = cv2.VideoWriter(video_name2, -1, cap.get(cv2.CAP_PROP_FPS),
(width, height))
video3 = cv2.VideoWriter(video_nameDen, -1, cap.get(cv2.CAP_PROP_FPS),
(width, height))
video4 = cv2.VideoWriter(video_nameDen2, -1, cap.get(cv2.CAP_PROP_FPS),
(width, height))
video5 = cv2.VideoWriter(video_nameBor, -1, cap.get(cv2.CAP_PROP_FPS),
(width, height))
video6 = cv2.VideoWriter(video_nameBor2, -1, cap.get(cv2.CAP_PROP_FPS),
(width, height))
for image in imag:
video.write(cv2.imread(os.path.join(image_folder, image)))
video2.write(cv2.imread(os.path.join(image_folder, image)))
for image in imagDen:
video3.write(cv2.imread(os.path.join(image_folderDen, image)))
video4.write(cv2.imread(os.path.join(image_folderDen, image)))
for image in imagBor:
video5.write(cv2.imread(os.path.join(image_folderBor, image)))
video6.write(cv2.imread(os.path.join(image_folderBor, image)))
cv2.destroyAllWindows()
video.release()
video2.release()
video3.release()
video4.release()
video5.release()
video6.release()