def cartoon(srcColor):
srcGray=cv2.cvtColor(srcColor,cv2.COLOR_BGR2GRAY)
print srcGray.shape,srcColor.shape
cv2.medianBlur(srcGray,5,srcGray)
mask=srcGray.copy().astype(np.uint8)
edges=srcGray.copy().astype(np.uint8)
### sketch detection
cv2.Laplacian(srcGray,cv2.CV_8U,edges,5)
cv2.threshold(edges,60,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU,mask)
outImg=srcColor.copy()
tmp=outImg.copy()
### bilateral filtering ###
rep=10
for i in xrange(rep):
size=9;sigmaColor=9;sigmaSpace=7
cv2.bilateralFilter(outImg,size,sigmaColor,sigmaSpace,tmp)
cv2.bilateralFilter(tmp,size,sigmaColor,sigmaSpace,outImg)
output=cv2.bitwise_and(srcColor,srcColor,mask=mask)
cv2.edgePreservingFilter(output,output)
return output
def detectRover(self, argFrame):
frame = self.frame
hsvFrame = self.frame
thresh = self.frame[:,:,0]
rGreen = (38,67,155,198,0,255)
rPink = (165,182,155,192,0,255)
hsvFrame = cv2.cvtColor(self.frame.copy(), cv2.COLOR_BGR2HSV)
thresh = cv2.inRange(hsvFrame.copy(),np.array([rGreen[0],rGreen[2],rGreen[4]]),np.array([rGreen[1],rGreen[3],rGreen[5]]))
thresh = cv2.medianBlur(thresh.copy(),5)
thresh = cv2.erode(thresh.copy(), erodeElem)
#thresh = cv2.erode(thresh.copy(), erodeElem)
thresh = cv2.dilate(thresh.copy(), dilateElem)
thresh = cv2.dilate(thresh.copy(), dilateElem)
_, contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) != 1:
return -1
(x,y,w,h) = cv2.boundingRect(contours[0])
greenPt = (int((x+x+w)/2),int((y+y+h)/2))
thresh = cv2.inRange(hsvFrame.copy(),np.array([rPink[0],rPink[2],rPink[4]]),np.array([rPink[1],rPink[3],rPink[5]]))
thresh = cv2.medianBlur(thresh.copy(),5)
thresh = cv2.erode(thresh.copy(), erodeElem)
#thresh = cv2.erode(thresh.copy(), erodeElem)
thresh = cv2.dilate(thresh.copy(), dilateElem)
thresh = cv2.dilate(thresh.copy(), dilateElem)
_, contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) != 1:
return -1
(x,y,w,h) = cv2.boundingRect(contours[0])
pinkPt = (int((x+x+w)/2),int((y+y+h)/2))
self.roverPos = (int((greenPt[0]+pinkPt[0])/2),int((greenPt[1]+pinkPt[1])/2))
angle = getAngle(pinkPt[0],pinkPt[1],greenPt[0],greenPt[1])
self.roverHeading = 360+angle[2]*-1
return greenPt, pinkPt
def input_filter(img):
img = cv2.medianBlur(img, 3)
img = cv2.medianBlur(img, 3)
img = cv2.medianBlur(img, 3)
img = cv2.medianBlur(img, 5)
img = cv2.bilateralFilter(img, 20, 50, 10)
return img
def smooth(self,image):
l,a,b = cv2.split(cv2.cvtColor(image, cv.CV_BGR2Lab))
a_new = cv2.medianBlur(a, 15)
b_new = cv2.medianBlur(b, 15)
return cv2.cvtColor(cv2.merge((l, a_new, b_new)), cv.CV_Lab2BGR)
def get_vessels(img,side):
#convert to grayscale
#img_gray=cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#equilized = cv2.equalizeHist(img_gray)
green_channel = img[:,:,1]
threshold =np.max(green_channel)*0.9
#crop image
gch_crop1=green_channel[:, (green_channel != 0).sum(axis=0) != 0]
gch_crop2=gch_crop1[(gch_crop1 != 0).sum(axis=1) != 0,:]
green_channel=gch_crop2
#rotate by optical disc
dummy,gch_bin = cv2.threshold(green_channel, threshold,255 ,cv2.THRESH_BINARY)
i,j = np.unravel_index(gch_bin.argmax(), gch_bin.shape)
if ((gch_bin.shape[1]/2 < j) and side=='left') or ((gch_bin.shape[1]/2 > j) and side=='right'):
green_channel=np.rot90(green_channel,2)
#25 x 25 median filter
gch_mf = cv2.medianBlur(green_channel,35)
#gch_nl = cv2.fastNlMeansDenoising(green_channel,h=10)
gch_norm = green_channel - gch_mf
gch_norm_norm = cv2.medianBlur(gch_norm,35)
#convert to binary image
thresh,gch_norm_bin = cv2.threshold(gch_norm,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
gch_norm_bin_norm = cv2.medianBlur(gch_norm_bin,35)
return gch_norm_bin_norm
def medianFilter(path, i=0):
import cv2
spath = path+'Batch260615-001-#17-100FPS-50mlPmin-2-%04d.png' %i
# spath = path+'Check\\imgSubbed-%d.jpg' %i
if os.path.exists(spath):
print("File found!")
else:
print("File not found!")
print(os.listdir(path))
img = cv2.imread(spath,0)
im1 =img.copy()
im2 = img.copy()
for ii in range(40):
im1 = cv2.medianBlur(im1, ksize=5)
if ii%2 == 0:
im2 = cv2.medianBlur(im2, ksize=1+ii)
cv2.imshow('im1', im1)
cv2.imshow('im2', im2)
# cv2.waitKey(5)
# img = cv2.imread('die.png')
print('Denoising')
dst = cv2.fastNlMeansDenoising(img,None,10,7,21)
cv2.imshow('img', img)
cv2.imshow('dst', dst)
cv2.imwrite(path + 'img.jpg', img)
cv2.imwrite(path + 'dst.jpg', dst)
cv2.waitKey(5)
print('finished')
def getMaskHSV(self, frame, background, channel='s'):
if channel == 'h':
c = 0
elif channel == 's':
c = 1
elif channel == 'v':
c = 2
else:
c = 0
print 'warning: wrong channel on getMaskHSV'
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
background = cv2.cvtColor(background, cv2.COLOR_BGR2HSV)
ch = frame[:,:,c]
bg = background[:,:,c]
mask = cv2.absdiff(ch,bg)
mask = cv2.threshold(mask,30,255,cv2.THRESH_BINARY)[1]
mask = cv2.medianBlur(mask, 7)
element = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3))
mask = cv2.morphologyEx(mask, cv2.MORPH_DILATE, element)
element = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(13,13))
mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, element)
mask = cv2.medianBlur(mask, 9)
return mask
def render(self,frame):
canvas = cv2.imread("pen.jpg", cv2.CV_8UC1)
numDownSamples = 2
img_rgb = frame
# number of downscaling steps
numBilateralFilters = 3
# number of bilateral filtering steps
# -- STEP 1 --
# downsample image using Gaussian pyramid
img_color = img_rgb
for _ in xrange(numDownSamples):
img_color = cv2.pyrDown(img_color)
# repeatedly apply small bilateral filter instead of applying
# one large filter
for _ in xrange(numBilateralFilters):
img_color = cv2.bilateralFilter(img_color, 9, 9, 3)
# upsample image to original size
for _ in xrange(numDownSamples):
img_color = cv2.pyrUp(img_color)
# convert to grayscale and apply median blur
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
img_blur = cv2.medianBlur(img_gray, 3)
# detect and enhance edges
img_edge = cv2.adaptiveThreshold(img_blur, 255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY, 9, 2)
return cv2.multiply(cv2.medianBlur(img_edge,7), canvas, scale=1./256)
def filter_smooth_thres(self, RANGE, color):
for (lower, upper) in RANGE:
lower = np.array(lower, dtype='uint8')
upper = np.array(upper, dtype='uint8')
mask_bottom = cv2.inRange(self.img_roi_bottom_hsv, lower, upper)
mask_top = cv2.inRange(self.img_roi_top_hsv, lower, upper)
blurred_bottom = cv2.medianBlur(mask_bottom, 5)
blurred_top = cv2.medianBlur(mask_top, 5)
# Morphological transformation
kernel = np.ones((2, 2), np.uint8)
smoothen_bottom = blurred_bottom #cv2.morphologyEx(blurred, cv2.MORPH_OPEN, kernel, iterations=5)
smoothen_top = blurred_top # cv2.morphologyEx(blurred, cv2.MORPH_OPEN, kernel, iterations=5)
"""
if self.debug:
cv2.imshow('mask bottom ' + color, mask_bottom)
cv2.imshow('blurred bottom' + color, blurred_bottom)
cv2.imshow('mask top ' + color, mask_top)
cv2.imshow('blurred top' + color, blurred_top)
"""
return smoothen_bottom, smoothen_top
def basic_seg(img, images):
noOfFrames = len(images)
bgFrame = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
for i in range(1, 4):
bgFrame = bgFrame / 2 + \
cv2.cvtColor((images[i]),
cv2.COLOR_BGR2GRAY) / 2
# Array to save the object locations
objLocs = np.array([None, None])
# Kernel for morphological operations
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
# Display the frames like a video
# Read each frame
frame = images[1]
# Perform background subtraction after median filter
diffFrame = cv2.absdiff(cv2.cvtColor(cv2.medianBlur(frame, 7), \
cv2.COLOR_BGR2GRAY), cv2.medianBlur(bgFrame, 7))
# Otsu thresholding to create the binary image
[th, bwFrame] = cv2.threshold(diffFrame, 0, 255, cv2.THRESH_OTSU)
# Morphological opening operation to remove small blobs
bwFrame = cv2.morphologyEx(bwFrame, cv2.MORPH_OPEN, kernel)
return bwFrame
def hsv_to_im_mask(im_hsv, hsv_lows, hsv_highs, is_bucket=False, is_arm=False):
if is_bucket:
# mask by threshold
im_mask = cv2.inRange(im_hsv, hsv_lows, hsv_highs)
im_mask = cv2.medianBlur(im_mask, 7)
# erode
im_mask = cv2.erode(im_mask, None, iterations=2)
# dilate
im_mask = cv2.dilate(im_mask, None, iterations=3)
elif is_arm:
# mask by threshold
im_mask = cv2.inRange(im_hsv, hsv_lows, hsv_highs)
im_mask = cv2.medianBlur(im_mask, 9)
# erode
# im_mask = cv2.erode(im_mask, None, iterations=2)
# dilate
im_mask = cv2.dilate(im_mask, None, iterations=3)
else:
# mask by threshold
im_mask = cv2.inRange(im_hsv, hsv_lows, hsv_highs)
im_mask = cv2.medianBlur(im_mask, 5)
# erode
# im_mask = cv2.erode(im_mask, None, iterations=2)
# dilate
im_mask = cv2.dilate(im_mask, None, iterations=3)
return im_mask
def extractFromVideo(inPath,out_paths=['train.txt','test.txt','val.txt'],MIN_FRAMES = 10,DO_RESIZE=True,new_sz = (40,80)):
#Default values
MAX_FRAMES = 100
ALPHA = 0.25
print "Starting background subtraction and object tracking........... %s"%inPath
cap = cv2.VideoCapture(inPath)
ret, prev_frame = cap.read()
w = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)); h = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))
w_crop = 80; h_crop = 160
def cap_read():
if cap.isOpened():
ret, frame = cap.read()
if ret:
return frame
return None
bgsubImpl = bgsub.get_instance(bgsub.BGMethod.EIGEN_SUBSTRACTION,cap_read)
bgsubImpl.setShape((h,w))
N = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT));
prv_mean = None; prev_img=None; i=0;
frames =[];
while(True):
mask_frame = bgsubImpl.process()
mask_frame = cv2.medianBlur(mask_frame,5)
mask_frame = cv2.medianBlur(mask_frame,3)
print 'Proceesing ... {0}%\r'.format((i*100/N)),
if bgsubImpl.isFinish():
break
# labelling
#img = np.zeros((h,w,3), np.uint8) # Create a black image
img = bgsubImpl.cur_frame
points = np.column_stack(np.where(mask_frame==1))
if points.shape[0] > 0:
mean = points.mean(axis=0)
if not prv_mean is None:
mean = ALPHA*mean + (1-ALPHA)*prv_mean
(y,x)=np.int32(mean);
if x-w_crop/2>0 and x+w_crop/2<w and y-h_crop/2>0 and y+h_crop/2<h :
img = img[y-h_crop/2:y+h_crop/2,x-w_crop/2:x+w_crop/2];
if DO_RESIZE:
i=i+1;
img = cv2.resize(img,new_sz);
img = np.asarray(img,dtype='float64')/256;
frames.append(img.flatten());
prv_mean = np.int32(mean);
if i % MAX_FRAMES == 0:
write(frames,out_paths,min_frames=MIN_FRAMES)
cap.release();
if frames.__len__() > MIN_FRAMES*2:
write(frames,out_paths,min_frames=MIN_FRAMES)
def read_images(fpath):
lines = utils.read_image_list(fpath)
logger.info('loading data: {}'.format(fpath))
X_data, y_data = [], []
for inst_path, truth_path in lines:
inst, truth = [cv2.imread(p, cv2.IMREAD_GRAYSCALE)
for p in (inst_path, truth_path)]
assert inst is not None and truth is not None, (inst_path, truth_path)
pad_h, pad_w = [x / 2 for x in MODEL_INPUT_SHAPE]
padded = cv2.copyMakeBorder(inst, pad_h, pad_h, pad_w, pad_w,
cv2.BORDER_REFLECT)
m7 = cv2.medianBlur(padded, 7)
m15 = cv2.medianBlur(padded, 15)
c7 = 255 - cv2.subtract(m7, padded)
c15 = 255 - cv2.subtract(m15, padded)
# (c, h, w) layout
input = np.array((padded, m7, m15, c7, c15))
truth = truth.reshape((1,) + truth.shape)
# pad input image
X_data.append(input)
y_data.append(truth)
return X_data, y_data
def GetEdges(self,imgs):
'''
入力されたimgのedgeを入手して返す
args : imgs -> 画像, もしくは画像のリスト
dst : edges -> 入力画像のedgeが入った画像，もしくはリスト
param: threshold1 -> 低い方の閾値
threshold2 -> わからん
apertureSize -> 繋がっていないエッジの補完に関するparam
'''
# imgかtmpか
if len(imgs) == len(self.scale):
'''tmpに対する処理'''
for i in range(len(self.scale)):
# imgs[i] = cv2.GaussianBlur(imgs[i], (9,9), 2**1)
imgs[i] = cv2.medianBlur(imgs[i],9)
imgs[i] = cv2.filter2D(imgs[i], cv2.CV_8U, self.sharpenKernel)
imgs[i] = cv2.Canny(imgs[i], threshold1= 90, threshold2= 200,apertureSize = 3)
else:
'''imgに対する処理'''
# imgs = cv2.GaussianBlur(imgs, (9,9), 2**1)
imgs = cv2.medianBlur(imgs,9)
imgs = cv2.filter2D(imgs, cv2.CV_8U, self.sharpenKernel)
imgs = cv2.Canny(imgs, threshold1= 90, threshold2= 200,apertureSize = 3)
edges = imgs
return edges
def update_disparity_map(self):
"""
Update disparity map in GUI.
The disparity image is normalized to the range 0-255 and then divided by
255, because OpenCV multiplies it by 255 when displaying. This is
because the pixels are stored as floating points.
"""
#key = ord('a')
#while not key == ord('n'):
print "Getting disparity map"
disparity = self.block_matcher.get_disparity(self.pair)
print "Got disparity map"
norm_coeff = 255 / disparity.max()
new_disp = cv2.resize(disparity,None,fx=0.6, fy=0.6, interpolation = cv2.INTER_CUBIC)
print "Bluring disparity map"
disp = (new_disp * norm_coeff / 255)
filter_disp = cv2.medianBlur(disp, 5)
filter_disp = cv2.medianBlur(filter_disp, 5)
self.cvImage = filter_disp
cv2.imshow(self.window_name, self.cvImage)
print "repainted image"
def proc_user(user):
user[user==1]=255
for i,u in enumerate(user):
u = cv2.medianBlur(u, 3)
user[i] = u
user.swapaxes(0,1)
for i,u in enumerate(user):
u = cv2.medianBlur(u, 9)
user[i] = u
user.swapaxes(0,1)
#---------------------CONTOUR--------------------------------------------
# for i,u in enumerate(user):
# # u = cv2.medianBlur(u, 3)
# contours, hierarchy = cv2.findContours(u.copy(),cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
# im = zeros(u.shape)
# # cnt = contours[4]
# maxl = 0
# biggest_cnt = None
# for cnt in contours:
# if len(cnt) > maxl:
# maxl = len(cnt)
# biggest_cnt = cnt
# cv2.drawContours(im,[biggest_cnt],0,255,-1)
# user[i] = im
#---------------------CONTOUR--------------------------------------------
user[user>0] = 1
return user
def getGestureRegion(self, frameNum):
""" Get gesture region for the given frame """
# get Depth frame
depthData = self.getFrame(self.depth, frameNum)
depthGray = cv2.cvtColor(depthData, cv2.cv.CV_RGB2GRAY)
# get user segmentation frame
userSeg = self.getFrame(self.user, frameNum)
userSegGray = cv2.cvtColor(userSeg, cv2.cv.CV_RGB2GRAY)
userSegGray = cv2.medianBlur(userSegGray, 5) # Median filter on original user image
# Convert user to binary image
threshold = 128
_, userBinImg = cv2.threshold(userSegGray, threshold, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
depthGray[np.where(userBinImg == 0)] = 0
depthGray = cv2.medianBlur(depthGray, 5)
depthRealValue = depthGray.astype(np.float32) # depth value of real world (0-maxDepth)
# Convert to depth values
depthRealValue = depthRealValue / 255.0 * float(self.data['maxDepth'])
depthRealValue = depthRealValue.round()
depthRealValue = depthRealValue.astype(np.uint16)
# scale depthGray to 0-255
depthGray = depthGray.astype(np.uint16)
depthGray = bytescale(depthGray)
depthImgValue = np.copy(depthGray)
return depthImgValue, depthRealValue
def render(self,frame): numDownSamples = 2 img_rgb = frame # number of downscaling steps numBilateralFilters = 7 # number of bilateral filtering steps # -- STEP 1 -- # downsample image using Gaussian pyramid img_color = img_rgb for _ in xrange(numDownSamples): img_color = cv2.pyrDown(img_color) # repeatedly apply small bilateral filter instead of applying # one large filter for _ in xrange(numBilateralFilters): img_color = cv2.bilateralFilter(img_color, 9, 9, 7) # upsample image to original size for _ in xrange(numDownSamples): img_color = cv2.pyrUp(img_color) # convert to grayscale and apply median blur img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY) img_blur = cv2.medianBlur(img_gray, 7) # detect and enhance edges img_edge = cv2.adaptiveThreshold(img_blur, 255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY, 9, 2) # -- STEP 5 -- # convert back to color so that it can be bit-ANDed with color image img_edge = cv2.cvtColor(img_edge, cv2.COLOR_GRAY2RGB) final = cv2.bitwise_and(img_color, img_edge) return cv2.medianBlur(final,7)
def track_ball(self,cv_image):
# Image is a np array (not a ros msg)
imgHSV = cv2.cvtColor(cv_image,cv2.COLOR_BGR2HSV)
#cv2.imshow("image_view", imgHSV)
imgHSV = cv2.medianBlur(imgHSV,3)
#cv2.imshow("image_view_blur1", imgHSV)
#hsv_min = np.array([150,100,70])
#hsv_max = np.array([255,255,255])
hsv_min = np.array([150,100,70])
hsv_max = np.array([245,255,255])
img_thr = cv2.inRange(imgHSV,hsv_min,hsv_max)
#cv2.imshow("image_thr", img_thr)
img_thr = cv2.medianBlur(img_thr,5)
#cv2.imshow("image_thr_blur", img_thr)
# Setup SimpleBlobDetector parameters.
params = cv2.SimpleBlobDetector_Params()
params.filterByColor = True
params.blobColor = 255
# Filter by Area.
params.filterByArea = True
params.minArea = 100
params.maxArea = 300
# Filter by Circularity
params.filterByCircularity = True
params.minCircularity = 0.5
# Filter by Convexity
params.filterByConvexity = True
params.minConvexity = 0.87
# Filter by Inertia
params.filterByInertia = True
params.minInertiaRatio = 0.5
# Create a detector with the parameters
ver = (cv2.__version__).split('.')
if int(ver[0]) < 3 :
detector = cv2.SimpleBlobDetector(params)
else :
detector = cv2.SimpleBlobDetector_create(params)
keypoints = detector.detect(img_thr)
if keypoints:
x = keypoints[0].pt[0]
y = keypoints[0].pt[1]
t = rospy.get_time()
if x and y:
self.pub.publish(x = x, y = y, t = t)
im_with_keypoints = cv2.drawKeypoints(img_thr, keypoints, np.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
def saveCroppedImage(self):
im_color = None
im_mask = None
if self.new_color_image and self.new_mask_image:
rospy.loginfo("Cropping image " + str(self.img_num))
im_color = copy.deepcopy(self.current_color_image)
im_mask = copy.deepcopy(self.current_mask_image)
self.new_color_image = False
self.new_mask_image = False
# Gray scale please, findContours needs it like that
mask_gray = cv2.cvtColor(im_mask, cv.CV_BGR2GRAY)
cv2.medianBlur(mask_gray, 7)
# Get the contours
contours, hierarchy = cv2.findContours(mask_gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# Get the biggest one (noise is little ones)
biggestcont = contours[0]
for cont in contours:
if len(biggestcont) < len(cont):
biggestcont = cont
cnt = biggestcont
# Get the rect
x, y, w, h = cv2.boundingRect(cnt)
# Crop stuff
crop = im_color[y : y + h, x : x + w]
# Save image
if self.img_num > 0: # First image is not usefull, it's too dark
rospy.loginfo(
"Saving image "
+ str(self.img_num)
+ " to "
+ self.store_path
+ "/"
+ self.object_name
+ "/"
+ self.object_name
+ "_image_"
+ str(self.img_num).zfill(3)
+ ".png"
)
cv2.imwrite(
self.store_path
+ "/"
+ self.object_name
+ "/"
+ self.object_name
+ "_image_"
+ str(self.img_num).zfill(3)
+ ".png",
crop,
)
else: # at least create the directory to store the images
rospy.loginfo("Skipping first image as it's too dark. Creating directory to store images.")
os.mkdir(self.store_path + "/" + self.object_name)
self.img_num += 1
# else: # there are 2 calls, one won't do anything. Don't hit me
# rospy.loginfo("Fake call...")
return
def __morph_ops__(self,mask): mask = cv2.medianBlur(np.uint8(mask),3) mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, KERNEL) mask = cv2.medianBlur(mask,3) mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE,KERNEL) mask = binary_fill_holes(mask) mask = remove_small_objects(mask,min_size=128,connectivity=2) return np.uint8(mask);
def __segment(self, gray):
# Substract BG to current frame
mostChanges = np.abs(sum(self.W-self.BG))
# Normalize max-min values
mostChanges = (mostChanges.clip(0, max=1)*255).astype('uint8')
self.__recognition = mostChanges.copy()
# Apply a threshold
_,mostChanges = cv2.threshold(mostChanges, 150, 255, cv2.THRESH_BINARY)
mostChanges = cv2.medianBlur(mostChanges, 9)
self.__mostChanges = mostChanges.copy()
# Apply median filter and multiply with the current scene
mask = cv2.medianBlur(mostChanges, 3)
mask = np.multiply(gray, mask)
mask = (mask*255).astype('uint8')
# Apply distance filter to minimize possible collisions
mask = cv2.distanceTransform(mask, cv2.cv.CV_DIST_L1, 3)
# Normalize between 0 and 255
mask = cv2.normalize(mask, mask, 0, 255, cv2.NORM_MINMAX).astype('uint8')
# Reduce noise
mask = cv2.GaussianBlur(mask, (-3,-3), 0.5)
# Apply threshold again to mask out real low values
# (Almost black zones, thus possible unions between objects)
_,mask = cv2.threshold(mask, 10, 255, cv2.THRESH_BINARY)
self.__mask = mask.copy()
contours,_ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
objs = []
for c in contours:
leftmost = c[:,:,0].min()
rightmost = c[:,:,0].max()
topmost = c[:,:,1].min()
bottommost = c[:,:,1].max()
area = ((rightmost - leftmost)*(bottommost-topmost))
if area < self.min_area:
continue
objs.append((leftmost, rightmost, topmost, bottommost))
found = 1
while found > 0:
found = 0
for a in objs:
for b in objs:
if a != b:
if self.__contains(a, b):
objs.remove(b)
found = 1
break
return objs
def step5_2():
R = cv2.imread(os.path.join('input', 'pair2-L.png'))
L = cv2.imread(os.path.join('input', 'pair2-R.png'))
#median filter both
L = cv2.medianBlur(L, 3)
R = cv2.medianBlur(R, 3)
apply_disparity_norm(L, R, '5-a-1-ncorr', 7)
def blobSmoothing(immask):
imfilter = cv2.medianBlur(immask,7)
imfilter = cv2.medianBlur(imfilter,5)
imfilter = cv2.medianBlur(imfilter,3)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
imfilter = cv2.dilate(imfilter,0.5*kernel)
imfilter = cv2.erode(imfilter,kernel)
return imfilter
def gen_multi_channel(padded):
m7 = cv2.medianBlur(padded, 7)
m15 = cv2.medianBlur(padded, 15)
c7 = 255 - cv2.subtract(m7, padded)
c15 = 255 - cv2.subtract(m15, padded)
# (c, h, w) layout
input = np.array((padded, m7, m15, c7, c15))
return input
def subtract_bgn(im, bgn):
""" Subtract the backgrounbd (bgn) from the image (im). Both have the same
dimensions (including number of channels)"""
# do a simple pre-filtering
bgn = cv2.medianBlur(bgn,3)
im = cv2.medianBlur(im,3)
fgbg = cv2.BackgroundSubtractorMOG()
# fgmask = fgbg.apply(bgn)
fgmask = fgbg.apply(im)
return fgmask
def Split_Blur_Thresh(frame): b,g,r = cv2.split(frame) b = cv2.medianBlur(b,7) g = cv2.medianBlur(g,7) r = cv2.medianBlur(r,7) b = cv2.adaptiveThreshold(b,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2) g = cv2.adaptiveThreshold(g,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2) r = cv2.adaptiveThreshold(r,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,11,2) return cv2.merge((b,g,r))
def different_filters(im):
im_median13 = cv2.medianBlur(im, 13)
im_median15 = cv2.medianBlur(im, 15)
images = [im, im_median13, im_median15]
for image in images:
plt.figure()
output.plot_image(image)
plt.figure()
output.plot_several_image_histograms(images, ['original', 'median13', 'median15'])
def CleanImgage(self, thresh = 30):
# Image processing
footprint = np.array([[-1,-1,-1],[-1,8,-1], [-1,-1,-1]])
self.clean_image = cv2.medianBlur(self.image, 5)
self.clean_image = cv2.filter2D(self.clean_image,-1,footprint)
self.clean_image = cv2.medianBlur(self.clean_image, 5)
self.markers = np.zeros_like(self.image)
self.markers[self.clean_image < threshold_otsu(self.image)] = 1
self.markers[self.clean_image >= ((threshold_otsu(self.image)*thresh)/100)] = 2
self.markers[self.clean_image >= ((threshold_otsu(self.image)*50)/100)] = 3
def median_blur(frame, blocksize = 3, debug = False):
"""
median blur with blocksize
"""
blocksize = np.int( (blocksize / 2) * 2 + 1 )
if debug:
print "median_blur: blocksize: ", blocksize
if blocksize in [3, 5]:
return cv2.medianBlur(frame, ksize = blocksize)
else:
return cv2.medianBlur(convto8(frame), ksize = blocksize)
plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(blur_2dconv), plt.title('Averaging')
plt.xticks([]), plt.yticks([])
plt.show()
# Image Blurring (Image Smoothing)
# https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_filtering/py_filtering.html#image-blurring-image-smoothing
# 1. Averaging
blur_ave = cv2.blur(img, (5, 5))
# 2. Gaussian Filtering
blur_gaus = cv2.GaussianBlur(img, (5, 5), 0)
# 3. Median Filtering (highly effective in removing salt-and-pepper noise)
blur_median = cv2.medianBlur(img, 5)
# 4. Bilateral Filtering (highly effective at noise removal while preserving edges)
blur_bilat = cv2.bilateralFilter(img, 9, 75, 75)
# Plot all these filterings
titles = [
'Original Image', '2D Convolution', 'Averaging', 'Gaussian Filtering',
'Median Filtering', 'Bilateral Filtering'
]
images = [img, blur_2dconv, blur_ave, blur_gaus, blur_median, blur_bilat]
for i in range(6):
plt.subplot(2, 3, i + 1), plt.imshow(images[i])
plt.title(titles[i])
plt.xticks([]), plt.yticks([])
import cv2 as cv
import numpy as np
img = cv.imread('../Images & Videos/russian_license_plate.jfif')
img_grey = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
license_cascade = cv.CascadeClassifier(
'../Images & Videos/russin_license_plate2.xml')
license_plate = license_cascade.detectMultiScale(img,
scaleFactor=1.3,
minNeighbors=2)
black_img = np.zeros((img.shape), dtype=np.uint8)
for (x, y, w, h) in license_plate:
blur = cv.medianBlur(img[y:y + h, x:x + w], 15)
img[y:y + h, x:x + w] = blur
cv.imshow('show', img)
cv.waitKey(0)
cv.destroyAllWindows()
def median_blur_demo(image):
#中值模糊
dst = cv.medianBlur(image, 5)
cv.imshow(" median_blur_demo", dst)
def median_blur_demo(image):
dst = cv.medianBlur(image, 9)
cv.imshow("dog_m_b",dst)
cv.imwrite("dog_m_b.jpg",dst)
import cv2
import numpy as np
img = cv2.imread('images/lines_target.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
blur = cv2.medianBlur(gray, 21)
edges = cv2.Canny(blur, 200, 400)
lines = cv2.HoughLines(edges, 1, np.pi / 180, 63)
for x in range(0, len(lines)):
for rho, theta in lines[x]:
a = np.cos(theta)
b = np.sin(theta)
x0 = a * rho
y0 = b * rho
x1 = int(x0 + 1000 * (-b))
y1 = int(y0 + 1000 * (a))
x2 = int(x0 - 1000 * (-b))
y2 = int(y0 - 1000 * (a))
cv2.line(img, (x1, y1), (x2, y2), (0, 0, 255), 2)
cv2.imshow('lab5-b', img)
cv2.waitKey(0)
def __call__(self, results):
"""Call functions to load image and get image meta information.
Args:
results (dict): Result dict from :obj:`mmseg.CustomDataset`.
Returns:
dict: The dict contains loaded image and meta information.
"""
if results.get('img_prefix') is not None:
filename = osp.join(results['img_prefix'],
results['img_info']['filename'])
else:
filename = results['img_info']['filename']
hdr = dict()
with open(filename) as f:
for line in f.readlines():
if '=' not in line:
continue
else:
key, value = line.split('=')
key = key.strip()
value = value.strip()
hdr[key] = value
assert hdr[
'file type'] == 'ENVI Standard', 'Require ENVI data: file type = ENVI Standard'
assert hdr['byte order'] == '0', 'Require ENVI data: byte order = 0'
assert hdr['x start'] == '0', 'Require ENVI data: x start = 0'
assert hdr['y start'] == '0', 'Require ENVI data: y start = 0'
assert hdr['interleave'].lower(
) == 'bsq', 'Require ENVI data: interleave = bsq'
assert int(hdr['data type']) <= len(
self.ENVI_data_type) and self.ENVI_data_type[int(
hdr['data type'])] != None
data_type = int(hdr['data type'])
header_offset = int(hdr['header offset'])
height = int(hdr['lines'])
width = int(hdr['samples'])
bands = int(hdr['bands'])
if hdr['interleave'].lower() == 'bsq':
img_bytes = np.fromfile(filename.replace('.hdr', '.raw'),
dtype=self.ENVI_data_type[data_type],
offset=header_offset)
img_bytes = img_bytes.reshape((bands, height, width))
img_bytes = img_bytes[self.channel_select, :, :]
if self.dataset_name == 'cholangiocarcinoma':
img_bytes = img_bytes[:, ::-1, :]
img_bytes = np.transpose(img_bytes, (1, 2, 0))
else:
img_bytes = np.zeros((height, width, bands),
dtype=self.ENVI_data_type[data_type])
pass
if self.to_float32:
img_bytes = img_bytes.astype(np.float32)
if self.normalization:
img_bytes -= self.mean[..., self.channel_select]
img_bytes /= self.std[..., self.channel_select]
############################################3
# img_bytes *= 16
# img_bytes += 128
# img_bytes = img_bytes.astype(np.uint8)
# img_bytes = img_bytes.astype(np.float32)
# img_bytes -= 128
# img_bytes /= 16
##############################################
if self.median_blur:
for band in range(img_bytes.shape[0]):
img_bytes[band, :, :] = cv2.medianBlur(img_bytes[band, :, :],
ksize=3)
results['filename'] = filename.replace('.hdr', '.png')
results['ori_filename'] = results['img_info']['filename'].replace(
'.hdr', '.png')
results['img'] = img_bytes
results['img_shape'] = img_bytes.shape
results['ori_shape'] = img_bytes.shape
# Set initial values for default meta_keys
results['pad_shape'] = img_bytes.shape
results['scale_factor'] = 1.0
results['channel_select'] = self.channel_select
results['channel_to_show'] = self.channel_to_show
num_channels = 1 if len(img_bytes.shape) < 3 else img_bytes.shape[2]
mean = np.ones(num_channels, dtype=np.float32) * 128
std = np.ones(num_channels, dtype=np.float32) * 16
results['img_norm_cfg'] = dict(mean=mean, std=std, to_rgb=False)
return results
cv2.blur(image, (7, 7)),
])
cv2.imshow("averaged", blurred)
blurred = np.hstack([
cv2.GaussianBlur(image, (3, 3), 0), # last val is std dev in x axis
cv2.GaussianBlur(image, (5, 5), 0), # when set to zero, it is
cv2.GaussianBlur(image, (7, 7), 0), # calculated for us
])
cv2.imshow("Gaussian", blurred)
# gaussian is more natural than averaged
blurred = np.hstack([
cv2.medianBlur(image, 3),
cv2.medianBlur(image, 5),
cv2.medianBlur(image, 7),
])
cv2.imshow("Median", blurred)
# Median replaces the center with the median pixel from surroundings
# instead of a mean. the median exists is an actual pixel value in the
# surroundings.
# median is good for reducing detail noise.
# whereas the other blurs have more of a "motion blur"
blurred = np.hstack([
cv2.bilateralFilter(image, 5, 21, 21),
cv2.bilateralFilter(image, 7, 31, 31),
cv2.bilateralFilter(image, 9, 41, 41),
img_HSV = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
#skin color range for hsv color space
HSV_mask = cv2.inRange(img_HSV, (0, 15, 0), (17, 170, 255))
HSV_mask = cv2.morphologyEx(HSV_mask, cv2.MORPH_OPEN, np.ones((3, 3),
np.uint8))
#converting from gbr to YCbCr color space
img_YCrCb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
#skin color range for hsv color space
YCrCb_mask = cv2.inRange(img_YCrCb, (0, 135, 85), (255, 180, 135))
YCrCb_mask = cv2.morphologyEx(YCrCb_mask, cv2.MORPH_OPEN,
np.ones((3, 3), np.uint8))
#merge skin detection (YCbCr and hsv)
global_mask = cv2.bitwise_and(YCrCb_mask, HSV_mask)
global_mask = cv2.medianBlur(global_mask, 3)
global_mask = cv2.morphologyEx(global_mask, cv2.MORPH_OPEN,
np.ones((4, 4), np.uint8))
HSV_result = cv2.bitwise_not(HSV_mask)
YCrCb_result = cv2.bitwise_not(YCrCb_mask)
global_result = cv2.bitwise_not(global_mask)
cv2.imwrite("1_HSV.jpg", HSV_result)
cv2.imwrite("2_YCbCr.jpg", YCrCb_result)
cv2.imwrite("3_global_result.jpg", global_result)
cv2.waitKey(0)
cv2.destroyAllWindows()
import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('dave.jpg', 0)
img2 = cv2.medianBlur(img, 5)
img = img2
ret, th1 = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)
th2 = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY, 11, 2)
th3 = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11, 2)
titles = [
'Original Image', 'Global Thresholding (v = 127)',
'Adaptive Mean Thresholding', 'Adaptive Gaussian Thresholding'
]
images = [img, th1, th2, th3]
for i in range(4):
plt.subplot(2, 2, i + 1), plt.imshow(images[i], 'gray')
plt.title(titles[i])
plt.xticks([]), plt.yticks([])
plt.show()
import numpy as np
import cv2 as cv
img = cv.imread('c://Intel//python//test1//blobs.jpg')
output = img.copy()
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
gray = cv.medianBlur(gray, 5)
circles = cv.HoughCircles(gray,
cv.HOUGH_GRADIENT,
1,
20,
param1=50,
param2=30,
minRadius=0,
maxRadius=0)
detected_circles = np.uint16(np.around(circles))
for (x, y, r) in detected_circles[0, :]:
cv.circle(output, (x, y), r, (0, 0, 0), 3)
cv.circle(output, (x, y), 2, (0, 255, 255), 3)
cv.imshow('output', output)
cv.waitKey(0)
cv.destroyAllWindows()
import matplotlib.pyplot as plt
import cv2
import numpy as np
import Func
Func.create_canvas_matplotlib(500, 500)
image = cv2.imread('keyboard.jpg')
kernel_averaging_10_10 = np.ones((10, 10), np.float32) / 100
kernel_averaging_5_5 = np.array([[0.04, 0.04, 0.04, 0.04, 0.04],
[0.04, 0.04, 0.04, 0.04, 0.04],
[0.04, 0.04, 0.04, 0.04, 0.04],
[0.04, 0.04, 0.04, 0.04, 0.04],
[0.04, 0.04, 0.04, 0.04, 0.04]])
smooth_image_f2D_5_5 = cv2.filter2D(image, -1, kernel_averaging_5_5)
smooth_image_f2D_10_10 = cv2.filter2D(image, -1, kernel_averaging_10_10)
smooth_image_b = cv2.blur(image, (10, 10))
smooth_image_bfi = cv2.boxFilter(image, -1, (10, 10), normalize=True)
smooth_image_gb = cv2.GaussianBlur(image, (9, 9), 0)
smooth_image_mb = cv2.medianBlur(image, 9)
while True:
smooth_image_bf = cv2.bilateralFilter(image, 5, 10, 10)
image_stack = Func.stackImages(
0.2, ([smooth_image_bf, smooth_image_f2D_5_5, smooth_image_gb
], [smooth_image_gbsmooth_image_mb]))
cv2.imshow("Stack", image_stack)
cv2.waitKey(0)
cv2.destroyAllWindows()
break
img = cv2.imread('images/image1.png')
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
blur3 = cv2.GaussianBlur(hsv, (3, 3), 0)
blur5 = cv2.GaussianBlur(hsv, (5, 5), 0)
blur7 = cv2.GaussianBlur(hsv, (7, 7), 0)
height, width, channels = hsv.shape
mask = np.zeros_like(img)
for j in range(height):
for i in range(width):
pixel = [
np.array([
hsv.item(j, i, 0),
hsv.item(j, i, 1),
hsv.item(j, i, 2),
blur3.item(j, i, 0),
blur5.item(j, i, 0),
blur7.item(j, i, 0)
],
dtype=np.float32)
]
results = gnb.predict(pixel)
if (results == 1):
mask[j, i] = [0, 0, 255]
mask = cv2.medianBlur(mask, 5)
img = cv2.addWeighted(img, 0.8, mask, 0.5, 0.2)
cv2.imshow('result', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
import cv2
camera = cv2.VideoCapture(0)
prev_frame = None
while camera.isOpened():
success, frame = camera.read()
if not success:
break
frame = cv2.medianBlur(frame, 5)
if prev_frame is not None:
mask = cv2.absdiff(frame, prev_frame)
_, mask = cv2.threshold(mask, 50, 255, cv2.THRESH_BINARY)
cv2.imshow("mask", mask)
else:
prev_frame = frame
cv2.imshow("prev", prev_frame)
cv2.imshow("frame", frame)
key_code = cv2.waitKey(1)
if key_code in [ord('q'), 27]:
break
camera.release()
cv2.destroyAllWindows()
split_image(dim_pix=244, im=WI_Hflip, location=region,
dtype=f"Mask", filename=f"Region_{region_number}_{Hflip}")
split_image(dim_pix=244, im=TC_Hflip, location=region, dtype=f"TC",
filename=f"Region_{region_number}_{Hflip}")
# Vertical Flip
TC_Vflip = np.flip(TC, 0)
WI_Vflip = np.flip(UWI, 0)
Vflip = "Vflip"
split_image(dim_pix=244, im=WI_Vflip, location=region,
dtype=f"Mask", filename=f"Region_{region_number}_{Vflip}")
split_image(dim_pix=244, im=TC_Vflip, location=region, dtype=f"TC",
filename=f"Region_{region_number}_{Vflip}")
# Blur filter
TC_Blur = cv2.medianBlur(TC, 5)
Blur = "Blur"
split_image(dim_pix=244, im=UWI, location=region, dtype=f"Mask",
filename=f"Region_{region}_{Blur}")
split_image(dim_pix=244, im=TC_Blur, location=region, dtype=f"TC",
filename=f"Region_{region}_{Blur}")
# Noise Filter
noise = sp_noise(TC, 0.05)
TC_noise = noise + TC
Noise = "Noise"
split_image(dim_pix=244, im=UWI, location=region, dtype=f"Mask",
filename=f"Region_{region_number}_{Noise}")
split_image(dim_pix=244, im=TC_noise, location=region, dtype=f"TC",
filename=f"Region_{region_number}_{Noise}")
else:
def zangwu_detect(self, mesh_bgr, model_type, name=None):
zangwu_dict = {
'defect': DEFECTS.LIANGPIN,
'defect_pts_list': [], # pts的list，每一个元素是一组缺陷的pts
}
if self.redis_db.get('cam1_zangwu_flag') == 0:
if model_type != self.current_model:
self.current_model = model_type
self.mesh_setting = self.mesh_settings[model_type]
self.liner_setting = self.liner_settings[model_type]
# gray = cv2.cvtColor(mesh_bgr, cv2.COLOR_BGR2GRAY)
gray = mesh_bgr
# t_start = time.time()
sh, sw = gray.shape[:2]
# img_gray = gray[55:sh - 50, 55:sw - 50]
img_gray = gray[85:sh - 80, 85:sw - 80]
# # 均值滤波
img_blur = cv2.blur(img_gray, (39, 39))
img_gray = cv2.blur(img_gray, (3, 3))
img_diff1 = cv2.subtract(img_gray, img_blur)
img_diff2 = cv2.subtract(img_blur, img_gray)
ret, img_binary1 = cv2.threshold(img_diff1, 30, 255, cv2.THRESH_BINARY)
ret, img_binary2 = cv2.threshold(img_diff2, 15, 255, cv2.THRESH_BINARY)
img_binary2 = cv2.bitwise_or(img_binary1, img_binary2)
sh, sw = img_binary1.shape[:2]
# 同轴光拍的图片对binary再进行中值滤波，去掉椒盐噪声
img_binary_blur = cv2.medianBlur(img_binary2, 5)
# 四个角减去干扰区域
# sh, sw = img_binary_blur.shape[:2]
img_binary_blur[sh - 123:sh, 0:134] = 0
img_binary_blur[0:130, sw - 125:sw] = 0
img_binary_blur[0:90, 0:90] = 0
img_binary_blur[sh - 90:sh, sw - 90:sw] = 0
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (6, 6))
img_binary_blur = cv2.morphologyEx(img_binary_blur, cv2.MORPH_CLOSE, kernel)
# 用连通域面积过滤
mask = np.zeros(img_binary2.shape)
cnts, hierarchy = cv2.findContours(img_binary_blur, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
for cnt in cnts:
cv2.drawContours(mask, [cnt], -1, (255, 255, 255), -1)
if len(cnts) > 0:
cnt_max = sorted(cnts, key=cv2.contourArea, reverse=True)[0]
num_p_max_zangwu = cv2.contourArea(cnt_max)
else:
num_p_max_zangwu = 0
num_p_all_zangwu = np.count_nonzero(mask)
# print("num_p_all_zangwu:", num_p_all_zangwu, "num_p_max_zangwu:", num_p_max_zangwu, "num_p_all_moque:",
# num_p_all_moque)
# origin 3500/350
if (num_p_all_zangwu > 13500) or (num_p_max_zangwu > 2080):
# zangwu_judge = True
zangwu_dict['defect'] = DEFECTS.ZANGWU
else:
# zangwu_judge = False
zangwu_dict['defect'] = DEFECTS.LIANGPIN
# print("zangwu_judge:", zangwu_judge)
# print("time of total:", time.time() - t_start)
# t_start = time.time()
# cv2.namedWindow('img_gray', cv2.WINDOW_NORMAL)
# cv2.resizeWindow('img_gray', 400, 400)
# cv2.imshow("img_gray", img_gray)
# cv2.namedWindow('mask', cv2.WINDOW_NORMAL)
# cv2.resizeWindow('mask', 400, 400)
# cv2.imshow("mask", mask)
# cv2.namedWindow('img_binary_blur', cv2.WINDOW_NORMAL)
# cv2.resizeWindow('img_binary_blur', 400, 400)
# cv2.imshow("img_binary_blur", img_binary_blur)
# # cv2.imwrite("./img_gray.png", img_gray)
# cv2.waitKey()
return zangwu_dict
#w=w+tempw+dis
res.append([x,y,w,h])
count+=2
else:
res.append(temp[count])
count+=1
output=[]
for i in range(len(temp)):
x,y,w,h=temp[i]
num=image[y-5:y+h+5,x-5:x+w+5]
#kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3))
#num=cv2.morphologyEx(num,cv2.MORPH_OPEN,kernel)
num=cv2.cvtColor(num,cv2.COLOR_BGR2GRAY)
#num=cv2.GaussianBlur(num,(5,5),1)
ret,th=cv2.threshold(num,220,255,cv2.THRESH_BINARY)#+cv2.THRESH_OTSU)
th=cv2.medianBlur(th,3)
output.append(th)
for i in range(len(output)):
plt.figure(i+1)
plt.imsave('C:/Users/gd/Desktop/redDigits/train/'+str(i)+'.jpg',output[i])
#plt.imsave('C:/Users/gd/Desktop/1'+str(i)+'.jpg',mask)
#plt.imsave('C:/Users/gd/Desktop/1.jpg',mask)
#ret,th=cv2.threshold(gray,130,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
#hsv=cv2.cvtColor(image,cv2.COLOR_BGR2HSV)
#redLower=np.array([0,10,100])
#redHigher=np.array([180,160,245])
#mask=cv2.inRange(hsv,redLower,redHigher)
out = cv2.VideoWriter(sys.argv[2], fourcc, 30.0, (vidWidth, vidHeight), True)
while (cap.isOpened()):
ret, frame = cap.read()
if ret == True:
# ORIGINAL GREEN
# lw = np.array([65,60,60])
# up = np.array([80,255,255])
lw = np.array([40, 30, 60]) #40 30 60
up = np.array([80, 255, 255])
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, lw, up)
mask_blur = cv2.medianBlur(mask, 5)
mask_blur = cv2.cvtColor(mask_blur, cv2.COLOR_GRAY2RGB)
# mask_inv = cv2.bitwise_not(mask_blur)
out.write(mask_blur)
cv2.imshow('res', mask_blur)
if cv2.waitKey(1) & 0XFF == ord('q'):
break
else:
break
cap.release()
out.release()
cv2.destroyAllWindows()
def gauss_process(image):
img = cv2.medianBlur(image, 5)
th_gauss = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11, 2)
cv2.fastNlMeansDenoising(th_gauss, th_gauss, 4)
view_image(th_gauss, 'gauss image')
import cv2
import numpy as np
# gray = cv2.imread('numbers_A4.png', cv2.IMREAD_GRAYSCALE)
gray = cv2.imread('numbers_gray_erode.png', cv2.IMREAD_GRAYSCALE)
gray = cv2.medianBlur(gray,3)
numbers_bin = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,11,2)
cv2.imwrite('numbers_bin_gaussian.png', numbers_bin)
numbers_bin = cv2.medianBlur(numbers_bin,3)
cv2.imwrite('numbers_bin_gaussian_filter_by_meidan.png', numbers_bin)
img_tensor = img_transform(img2)
# predict
with torch.no_grad():
img2 = img_tensor.unsqueeze(0).cuda().cpu()
pred = net(img2)
pred = pred.cpu().numpy().squeeze()
pred = np.argmax(pred, axis=0)
colorized = args.dataset_cls.colorize_mask(pred)
img = np.array(colorized.convert('RGB'))
kernel = np.ones((15, 15), np.uint8)
img = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
median = cv2.medianBlur(img, 17)
#write data to disk for training
writeTrainData(steeringValue, throttleValue, median,
int(framecount / 5))
#endTime = datetime.datetime.now()
#elapsedTime = endTime - beginTime
#if(elapsedTime.microseconds > 0.0):
# fps = round(1 / (elapsedTime.microseconds * 10**-6),2)
#cv2.putText(img,"fps: " + str(fps),(10,90), cv2.FONT_HERSHEY_SIMPLEX, 1,(0,0,255),4,cv2.LINE_AA)
#print(str(steeringValue) + ", " + str(throttleValue))
median = draw_user_angle(steeringValue, throttleValue, median)
mask = skip_margin(mask)
#plt.imshow(mask)
return mask
img = cv2.imread('./Data and Image/Image_Question4.bmp')
#newimg = img
newimg = img[480:1450, 150:1200]
cv2.imwrite('image_roi.bmp', newimg)
gray = cv2.cvtColor(newimg, cv2.COLOR_BGR2GRAY)
color = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
#cv2.imshow("color",color)
#define ROI
gray = cv2.medianBlur(gray, 3)
#cv2.imshow("gray",gray)
circles1 = cv2.HoughCircles(gray,
cv2.HOUGH_GRADIENT,
2,
100,
param1=160,
param2=80,
minRadius=65,
maxRadius=75)
for circle in circles1[0]:
cv2.circle(color, (circle[0], circle[1]), circle[2], (0, 255, 0), 3)
circles2 = cv2.HoughCircles(gray,
cv2.HOUGH_GRADIENT,
2,
def recognize(cam=None):
global prediction
if cam is None:
cam = cv2.VideoCapture(1)
if cam.read()[0] == False:
cam = cv2.VideoCapture(0)
hist = get_hand_hist()
x, y, w, h = 300, 100, 300, 300
while True:
text = ""
img = cam.read()[1]
img = cv2.flip(img, 1)
img = cv2.resize(img, (640, 480))
imgCrop = img[y:y + h, x:x + w]
imgHSV = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([imgHSV], [0, 1], hist, [0, 180, 0, 256], 1)
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
cv2.filter2D(dst, -1, disc, dst)
blur = cv2.GaussianBlur(dst, (11, 11), 0)
blur = cv2.medianBlur(blur, 15)
thresh = cv2.threshold(blur, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
thresh = cv2.merge((thresh, thresh, thresh))
thresh = cv2.cvtColor(thresh, cv2.COLOR_BGR2GRAY)
thresh = thresh[y:y + h, x:x + w]
(openCV_ver, _, __) = cv2.__version__.split(".")
if openCV_ver == '3':
contours = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[1]
elif openCV_ver == '4':
contours = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[0]
if len(contours) > 0:
contour = max(contours, key=cv2.contourArea)
# print(cv2.contourArea(contour))
if cv2.contourArea(contour) > 10000:
x1, y1, w1, h1 = cv2.boundingRect(contour)
save_img = thresh[y1:y1 + h1, x1:x1 + w1]
if w1 > h1:
save_img = cv2.copyMakeBorder(save_img, int((w1 - h1) / 2),
int((w1 - h1) / 2), 0, 0,
cv2.BORDER_CONSTANT,
(0, 0, 0))
elif h1 > w1:
save_img = cv2.copyMakeBorder(save_img, 0, 0,
int((h1 - w1) / 2),
int((h1 - w1) / 2),
cv2.BORDER_CONSTANT,
(0, 0, 0))
pred_probab, pred_class = keras_predict(model, save_img)
if pred_probab * 100 > 80:
text = get_pred_text_from_db(pred_class)
if text.lower() == 'f**k':
text = 'Love'
print(text)
blackboard = np.zeros((480, 640, 3), dtype=np.uint8)
splitted_text = split_sentence(text, 2)
put_splitted_text_in_blackboard(blackboard, splitted_text)
# cv2.putText(blackboard, text, (30, 200), cv2.FONT_HERSHEY_TRIPLEX, 1.3, (255, 255, 255))
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
res = np.hstack((img, blackboard))
# cv2.imshow("Recognizing gesture", res)
return res
def get_body(image):
gray = cv2.medianBlur(image, 5)
dst2 = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11, 2)
return dst2
def cartoonizer(now):
num_down = 2 # number of downsampling steps
num_bilateral = 7 # number of bilateral filtering steps
img_rgb = cv2.imread("./images/screen_capture_%s.jpg" % now)
# downsample image using Gaussian pyramid
img_color = img_rgb
for _ in range(num_down):
img_color = cv2.pyrDown(img_color)
# repeatedly apply small bilateral filter instead of
# applying one large filter
for _ in range(num_bilateral):
img_color = cv2.bilateralFilter(img_color,
d=9,
sigmaColor=9,
sigmaSpace=7)
# upsample image to original size
for _ in range(num_down):
img_color = cv2.pyrUp(img_color)
# convert to grayscale and apply median blur
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
img_blur = cv2.medianBlur(img_gray, 7)
rows, cols, channels = img_rgb.shape
roi = img_color[0:rows, 0:cols]
# detect and enhance edges
img_edge = cv2.adaptiveThreshold(img_blur,
255,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY,
blockSize=9,
C=2)
img_median = cv2.medianBlur(img_edge, 5)
edge_compare = np.concatenate((img_edge, img_median), axis=1)
cv2.imshow("edge_compare", edge_compare)
ret, mask = cv2.threshold(img_median, 10, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)
# convert back to color, bit-AND with color image
img_edge = cv2.cvtColor(img_median, cv2.COLOR_GRAY2RGB)
#img_cartoon = cv2.bitwise_and(img_color, img_edge)
img_cartoon_bg = cv2.bitwise_and(roi, roi, mask=mask)
img_cartoon_fg = cv2.bitwise_and(img_edge, img_edge, mask=mask_inv)
dst = cv2.add(img_cartoon_fg, img_cartoon_bg)
img_color[0:rows, 0:cols] = dst
# display
#cv2.imshow("original", img_rgb)
#cv2.imshow("edge", img_edge)
#cv2.imshow("mask_inv", mask_inv)
#cv2.imshow("color", img_color)
#cv2.imshow("mask", mask)
#cv2.imshow("cartoon", img_rgb)
result_compare = np.concatenate((img_rgb, img_color), axis=1)
cv2.imshow("result_compare", result_compare)
cv2.waitKey(0)
cv2.imwrite("./images/screen_capture_cartoonized_mask_%s.jpg" % now, mask)
cv2.imwrite("./images/screen_capture_cartoonized_%s.jpg" % now, img_rgb)
cv2.destroyAllWindows()
import cv2
import numpy as np
bs = cv2.createBackgroundSubtractorKNN() #k-Nearest Neighbor分类算法
camera = cv2.VideoCapture("1.avi") #导入视频，括号中为视频地址，0表示打开笔记本内置摄像头
while True:
ret, frame = camera.read() #ret为布尔值，当读取至视频最后一帧后，返回False
#frame为每一帧图像的三维矩阵
fgmask = bs.apply(frame)
fg2 = fgmask.copy()
blur = cv2.medianBlur(fg2, 5) #中值滤波
th = cv2.threshold(
blur, 254, 255, cv2.THRESH_BINARY
)[1] #图像的简单阈值处理，第一个参数：原图像，第二个参数：进行分类的阈值，第三个参数：高于（低于）阈值时赋予的新值，第四个参数：选择参数的方法
#第一个返回值：得到的阈值，第二个阈值：阈值化后的图像。此处只取第二个返回值，加[1]
dilated = cv2.dilate(th,
cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)),
iterations=2) #膨胀的次数
#图像的膨胀
image, contours, gihr = cv2.findContours(
dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
) #提取图像轮廓。参数1：图像，参数2：提取规则cv2.RETR_EXTERNAL：只找外轮廓，cv2.RETR_TREE：内外轮廓都找。
#参数3：输出轮廓内容格式。cv2.CHAIN_APPROX_SIMPLE：输出少量轮廓点。cv2.CHAIN_APPROX_NONE：输出大量轮廓点。
#计算轮廓的边界框，并加在图片上 #输出参数1：图像。输出参数2：轮廓列表。输出参数3：层级
for c in contours:
if cv2.contourArea(c) > 100:
(x, y, w, h) = cv2.boundingRect(c)
cv2.rectangle(
frame, (x, y), (x + w, y + h), (255, 255, 0),
2) #图像加框，参数1：图像，参数2：左上角坐标，参数3：右下角坐标，参数4：框的颜色，参数5：框的粗细
def _blur_median(image, ksize):
if ksize % 2 == 0:
ksize += 1
if ksize <= 1:
return image
return cv2.medianBlur(_normalize_cv2_input_arr_(image), ksize)
@author: anshu
"""
import cv2
import numpy as np
def get_frame(cap, scaling_factor):
_, frame = cap.read()
frame = cv2.resize(frame, None, fx=scaling_factor,
fy=scaling_factor, interpolation=cv2.INTER_AREA)
return frame
if __name__=='__main__':
cap = cv2.VideoCapture(0)
scaling_factor = 0.5
while True:
frame = get_frame(cap, scaling_factor)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
lower = np.array([0, 70, 60])
upper = np.array([50, 150, 255])
mask = cv2.inRange(hsv, lower, upper)
img_bitwise_and = cv2.bitwise_and(frame, frame, mask=mask)
img_median_blurred = cv2.medianBlur(img_bitwise_and, 5)
cv2.imshow('Input', frame)
cv2.imshow('Output', img_median_blurred)
c = cv2.waitKey(5)
if c == 27:
break
cv2.destroyAllWindows()
# will assume this contour correspondes to the area of the bottle cap
cnt = sorted(cnts, key=cv2.contourArea, reverse=True)[0]
# Get the radius of the enclosing circle around the found contour
((x, y), radius) = cv2.minEnclosingCircle(cnt)
# Draw the circle around the contour
cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2)
# Get the moments to calculate the center of the contour (in this case Circle)
M = cv2.moments(cnt)
center = (int(M['m10'] / M['m00']), int(M['m01'] / M['m00']))
points.appendleft(center)
elif len(cnts) == 0:
if len(points) != 0:
blackboard_gray = cv2.cvtColor(blackboard, cv2.COLOR_BGR2GRAY)
blur1 = cv2.medianBlur(blackboard_gray, 15)
blur1 = cv2.GaussianBlur(blur1, (5, 5), 0)
thresh1 = cv2.threshold(blur1, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
blackboard_cnts = cv2.findContours(thresh1.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[1]
if len(blackboard_cnts) >= 1:
cnt = sorted(blackboard_cnts,
key=cv2.contourArea,
reverse=True)[0]
if cv2.contourArea(cnt) > 1000:
x, y, w, h = cv2.boundingRect(cnt)
alphabet = blackboard_gray[y - 10:y + h + 10,
x - 10:x + w + 10]
newImage = cv2.resize(alphabet, (28, 28))
"""
This block iterates through all the images with png format in the directory or subdirectory under the source path.
Also, it skips iterating through the mask file. The open cv's medianBlur method applies the filter to the image, with
two kernels sized 3 and 5.
The newly found filtered images are stored in the new folders named after appending _m3 or _m5 to the original folder.
"""
for root, dirs, files in os.walk(path):
for file in files:
if file.endswith('.png') and (not file.startswith('m')):
print(os.path.join(root, file))
#Apply median filter of kernel size 5.
img = cv2.imread(os.path.join(root, file))
medianImg = cv2.medianBlur(img, 5)
#Save the file. Create the required directory if does not exist.
op_path5 = root + "_m5"
try:
if not os.path.exists(op_path5):
os.makedirs(op_path5)
except OSError as e:
raise
cv2.imwrite(os.path.join(op_path5, file), medianImg)
#Apply median filter of kernel size 3.
medianImg = cv2.medianBlur(img, 3)
op_path3 = root + "_m3"
def create_record(orig_picture, classes, size, per_num, TFRecordname, Output,
classes_num, save_path):
Name = save_path + '/' + TFRecordname + ".tfrecords"
writer = tf.python_io.TFRecordWriter(Name)
# print("创建写者成功！")
per_num = int(per_num) # 这个类型错误找了好久
size = int(size)
classes_num = int(classes_num)
for index, name in enumerate(classes):
class_path = orig_picture + "/" + name + "/*.jpg"
temp = 1
for item in glob.glob(str(class_path)):
# print("进入递归")
if temp < int(per_num):
try:
print("item: ", item)
img = cv2.imread(item, 0) # 灰度模式打开图像
img = cv2.medianBlur(img, 7) # 模糊图像，降噪
th1 = cv2.adaptiveThreshold(img, 255,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY_INV, 11,
2) # 背景黑色，物体白色
th2 = cv2.adaptiveThreshold(img, 255,
cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
cv2.THRESH_BINARY, 11,
2) # 背景白色，物体黑色
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,
(25, 25))
closed = cv2.morphologyEx(th1, cv2.MORPH_CLOSE, kernel)
# img = img.resize((SIZE, SIZE)) # 设置需要转换的图片大小
image, cnts, hierarchy = cv2.findContours(
closed.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
c = sorted(cnts, key=cv2.contourArea, reverse=True)[0]
rect = cv2.minAreaRect(c)
box = np.int0(cv2.boxPoints(rect))
cv2.drawContours(img, [box], -1, (0, 255, 0), 3)
# 矩形
Xs = [i[0] for i in box]
Ys = [i[1] for i in box]
x1 = min(Xs)
x2 = max(Xs)
y1 = min(Ys)
y2 = max(Ys)
if x1 < 0:
x1 = 0
if x2 < 0:
x2 = 0
if y1 < 0:
y1 = 0
if y2 < 0:
y2 = 0
hight = y2 - y1
width = x2 - x1
cropImg = th2[y1:y1 + hight, x1:x1 + width] # 裁剪
finish = cv2.resize(cropImg, (size, size)) # 重新给定图像大小，缩放图像
img_raw = finish.tobytes() # 将图片转化为原生bytes，numpy方法
print("分组:", index, "第", temp, "张")
no2 = "分组:" + str(index) + "第" + str(temp) + "张"
Output.setLabelText(no2)
example = tf.train.Example(features=tf.train.Features(
feature={
"label":
tf.train.Feature(int64_list=tf.train.Int64List(
value=[index])),
'img_raw':
tf.train.Feature(bytes_list=tf.train.BytesList(
value=[img_raw]))
}))
temp = temp + 1
writer.write(example.SerializeToString())
Output.setPercent((temp / (per_num * classes_num)) * 100)
QApplication.processEvents() # 实时显示
except Exception as e:
print(e)
else:
break
writer.close()
