def track(self, frame):
# Resize for efficiency
frame = cv2.pyrDown(frame)
frame = cv2.cvtColor(frame, cv.CV_BGR2Lab)
self.frame = frame
l,a,b = self.hist
# Convert to float32 so we can represent probability values
frame = frame.astype(np.float32)
lback = cv2.calcBackProject([frame], [0], l, [0,255], 1)
aback = cv2.calcBackProject([frame], [1], a, [0,255], 1)
bback = cv2.calcBackProject([frame], [2], b, [0,255], 1)
# Combine channels and convert to image
self.back = (aback * bback * lback ) * 255
self.back = self.back.astype(np.uint8)
tmp = np.array(self.back)
loc, contours = util.contour(tmp)
self.contours = contours
# Scale loc back up due to pyrDown
if loc != None:
loc = [x*2 for x in loc if loc != None]
return loc
def removeBackground(self, image):
discValue = 10
threshold = 1
hsvt = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
for roiHist in self.negHistograms:
dst = cv2.calcBackProject([hsvt],[0,1],roiHist,[0,180,0,256],1)
cv2.imshow('dst', dst)
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(discValue,discValue))
cv2.filter2D(dst, -1,disc,dst)
ret,thresh = cv2.threshold(dst,threshold,255,cv2.THRESH_BINARY_INV)
thresh = cv2.merge((thresh,thresh,thresh))
image = cv2.bitwise_and(image,thresh)
for roiHist in self.posHistograms:
dst = cv2.calcBackProject([hsvt],[0,1],roiHist,[0,180,0,256],1)
#cv2.imshow('dst', dst)
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(discValue,discValue))
cv2.filter2D(dst, -1,disc,dst)
ret,thresh = cv2.threshold(dst,threshold,255,cv2.THRESH_BINARY)
thresh = cv2.merge((thresh,thresh,thresh))
image = cv2.bitwise_and(image,thresh)
#res = np.hstack((thresh,res))
cv2.imshow('backProj', image)
return image
def meanShift(hsv, f1, f2, rois, mask):
if f1 is not None:
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
#import pdb; pdb.set_trace()
ff1 = cv2.normalize(f1,alpha=0,beta=255,norm_type=cv2.NORM_MINMAX)
ff2 = cv2.normalize(f2,alpha=0,beta=255,norm_type=cv2.NORM_MINMAX)
dst1 = cv2.calcBackProject([hsv], [0,2], ff1, [70, 180, 10, 255], 1)
dst2 = cv2.calcBackProject([hsv], [0,2], ff2, [70, 180, 10, 255], 1)
bMask = cv2.inRange(hsv, np.array((70., 0., 10.)), np.array((255.,255.,50.)))
wMask = cv2.inRange(hsv, np.array((70., 0., 200.)), np.array((255.,255.,255.)))
dst1 = cv2.bitwise_and(dst1, mask)
dst2 = cv2.bitwise_and(dst2, mask)
dst1 = cv2.bitwise_and(dst1, wMask)
dst2 = cv2.bitwise_and(dst2, bMask)
dstVis1 = cv2.applyColorMap(dst1, cv2.COLORMAP_JET)
dstVis2 = cv2.applyColorMap(dst2, cv2.COLORMAP_JET)
nRois = []
for (x0,y0), (x1,y1), flag in rois:
if flag:
x,y,w,h = cv2.meanShift(dst1, (x0,y0,x1-x0,y1-y0), term_crit)[1]
nRois.append( [(x, y), (x+w, y+h), flag] )
dst1[y:y+h, x:x+w] = 0
else:
x,y,w,h = cv2.meanShift(dst2, (x0,y0,x1-x0,y1-y0), term_crit)[1]
nRois.append( [(x, y), (x+w, y+h), flag] )
dst2[y:y+h, x:x+w] = 0
#cv2.imshow('dst1', dstVis1)
#cv2.imshow('dst2', dstVis2)
return nRois
return []
def update(self, frame):
# print "updating %d " % self.id
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
back_project = cv2.calcBackProject([hsv],[0], self.roi_hist,[0,180],1)
if args.get("algorithm") == "c":
ret, self.track_window = cv2.CamShift(back_project, self.track_window, self.term_crit)
pts = cv2.boxPoints(ret)
pts = np.int0(pts)
self.center = center(pts)
cv2.polylines(frame,[pts],True, 255,1)
if not args.get("algorithm") or args.get("algorithm") == "m":
ret, self.track_window = cv2.meanShift(back_project, self.track_window, self.term_crit)
x,y,w,h = self.track_window
self.center = center([[x,y],[x+w, y],[x,y+h],[x+w, y+h]])
cv2.rectangle(frame, (x,y), (x+w, y+h), (255, 255, 0), 2)
self.kalman.correct(self.center)
prediction = self.kalman.predict()
cv2.circle(frame, (int(prediction[0]), int(prediction[1])), 4, (255, 0, 0), -1)
# fake shadow
cv2.putText(frame, "ID: %d -> %s" % (self.id, self.center), (11, (self.id + 1) * 25 + 1),
font, 0.6,
(0, 0, 0),
1,
cv2.LINE_AA)
# actual info
cv2.putText(frame, "ID: %d -> %s" % (self.id, self.center), (10, (self.id + 1) * 25),
font, 0.6,
(0, 255, 0),
1,
cv2.LINE_AA)
def trackBiggestObject(self, frame):
if self.biggestObject == None:
return
c = self.biggestObject[0]
r = self.biggestObject[1]
w = self.biggestObject[2]
h = self.biggestObject[3]
if w == 0 or h == 0:
return
#mask = cv2.inRange(hsv_roi, np.array((0., 0.,0.)), np.array((180.,255.,255.)))
roi_hist = self.biggestObjectHistogram
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,256],1)
dst = cv2.calcBackProject([hsv],[0,1],roi_hist,[0,180,0,256],1)
#dst = cv2.calcBackProject([hsv],[0,1,2],roi_hist,[0,180,0,256,0,256],1)
#ret, self.movingObjects[i] = cv2.meanShift(dst, track_window, self.term_crit)
# apply meanshift to get the new location
ret, self.biggestObject = cv2.CamShift(dst, self.biggestObject, self.term_crit)
cv2.imshow('backproj',dst)
# Draw it on image
#pts = cv2.boxPoints(ret)
#pts = np.int0(pts)
#self.movingObjects.append(pts)
#img2 = cv2.polylines(frame,[pts],True, 255,2)
self.drawBiggestObjectContour(frame)
def camshift(self):
self.imgs=[]
while True:
try:
hsv = cv2.cvtColor(self.img, cv.CV_BGR2HSV)
mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
x0, y0, w, h = self.bb
x1 = x0 + w -1
y1 = y0 + h -1
hsv_roi = hsv[y0:y1, x0:x1]
mask_roi = mask[y0:y1, x0:x1]
hist = cv2.calcHist( [hsv_roi], [0], mask_roi, [16], [0, 180] )
cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX);
hist_flat = hist.reshape(-1)
self.imgs.append(hsv)
prob = cv2.calcBackProject(self.imgs, [0], hist_flat, [0, 180], 1)
prob &= mask
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
self.ellipse, self.bb = cv2.CamShift(prob, self.bb, term_crit)
cv2.rectangle(self.img, (self.bb[0], self.bb[1]), (self.bb[0]+self.bb[2], self.bb[1]+self.bb[3]), color=(255,0,0))
cv2.imshow("CAMShift", self.img)
k = cv2.waitKey(30) % 0x100
if k==27:
cv2.destroyAllWindows()
break
if k==114:
cv2.destroyAllWindows()
self.start()
break
_, self.img = self.cam.read()
except KeyboardInterrupt:
cv2.destroyAllWindows()
break
def track(self, frame):
for i in range(len(self.movingObjects)):
track_window = self.movingObjects[i]
#track_window = (c,r,w,h)
c = track_window[0]
r = track_window[1]
w = track_window[2]
h = track_window[3]
if w == 0 or h == 0:
continue
#mask = cv2.inRange(hsv_roi, np.array((0., 0.,0.)), np.array((180.,255.,255.)))
roi_hist = self.histograms[i]
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,256],1)
dst = cv2.calcBackProject([hsv],[0,1],roi_hist,[0,180,0,256],1)
#ret, self.movingObjects[i] = cv2.meanShift(dst, track_window, self.term_crit)
# apply meanshift to get the new location
ret, self.movingObjects[i] = cv2.CamShift(dst, track_window, self.term_crit)
# Draw it on image
#pts = cv2.boxPoints(ret)
#pts = np.int0(pts)
#self.movingObjects.append(pts)
#img2 = cv2.polylines(frame,[pts],True, 255,2)
self.drawContours(frame)
def bpSignificantSquares(img,sigSquares,probThresh): print '-BP-' #get a list of the regions of the image for which the histogram for backproyection will be calculated print '-BP-getRegionList' myTime = clock() regionList = getSignificantRegions(img,sigSquares) print '-BP- len of regionList: '+str(len(regionList)) print '-BP- ===>takes '+str(clock()-myTime) myTime = clock() mask = np.zeros((img.shape[:2]),np.uint8) print '-BP-gethist and bp' myTime = clock() for region in regionList: hist = getHist(region)[0] aux = cv2.calcBackProject([cv2.cvtColor(img,cv2.cv.CV_BGR2HSV)], [0,1], hist, [0,180,0,256],1) bp = cv2.threshold(aux,probThresh,255,cv2.THRESH_BINARY)[1] mask = cv2.max(mask,bp) print '-BP- ===>takes '+str(clock()-myTime) myTime = clock() aux = np.zeros((mask.shape),np.uint8) print '-BP-getComponentOf ' aux = getComponentOf(mask,(mask.shape[1]/2,mask.shape[0]/2),True) print '-BP- ===>takes '+str(clock()-myTime) myTime = clock() return cv2.merge([mask,]*3) , cv2.merge([aux*255,]*3)
def draw_window(frame):
# setup initial location of window
r,h,c,w = 250,90,400,125 # simply hardcoded the values
track_window = (c,r,w,h)
# set up the ROI for tracking
roi = frame[r:r+h, c:c+w]
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))
roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180])
cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX)
# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1)
# apply meanshift to get the new location
ret, track_window = cv2.CamShift(dst, track_window, term_crit)
# Draw it on image
pts = cv2.boxPoints(ret)
pts = np.int0(pts)
img2 = cv2.polylines(frame,[pts],True, 255,2)
io.imshow(img2)
def backproject():
im = cv2.imread("DSC_0869.JPG")
#im = cv2.resize(im, None, fx = 0.25, fy = 0.25)
#image => hsv, hist
hsv = cv2.cvtColor( im, cv2.COLOR_BGR2HSV)
#cv2.imshow("hsv", hsv)
imHist = cv2.calcHist([hsv], [0,1], None, [180, 256],[0,180,0,256])
bckP = cv2.calcBackProject([hsv], [0,1], imHist,[0,180,0,256], 1)
#cv2.imshow("bp", bckP)
kernel = cv2.getStructuringElement( cv2.MORPH_ELLIPSE, (3,3))
closing = cv2.morphologyEx(bckP, cv2.MORPH_CLOSE, kernel)
#cv2.imshow("eroded", closing)
##dst = cv2.filter2D(closing, -1,kernel)
##cv2.imshow('2d', dst)
ret,thresh = cv2.threshold(closing, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
#cv2.imshow("thresh", thresh)
fm1 = cv2.merge((thresh,thresh,thresh))
res1 = cv2.bitwise_and(im, fm1, mask = None)# mask here has no significance
#cv2.imshow("first and", res1)
#make (lower bound) G= 180 for proper target. G= 90 makes its edges disappear a leeettle
mask = cv2.inRange(hsv, np.array([5,90,50], dtype = np.uint8), np.array([49,255,205], dtype = np.uint8))
mask_inv = cv2.bitwise_not(mask)
res = cv2.bitwise_and(res1, res1, mask = mask_inv)
cv2.imwrite("final.jpg", res)
kernel=cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3))
res=cv2.erode(res,kernel,iterations=1)
cv2.imwrite("bckP.JPG",res)
extractblob(res)
def apply_skin_mask(self, frame):
# transform from rgb to hsv
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# detect skin using the hand histogram
self.skin_mask = cv2.calcBackProject([hsv], [0, 1], self.hand_histogram, [0, 180, 0, 256], 1)
# create a elliptical kernel (12 is the best in my case)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))
cv2.filter2D(self.skin_mask, -1, kernel, self.skin_mask)
# Apply gaussian filter on the result to give better result
cv2.GaussianBlur(self.skin_mask, (3, 3), 0, self.skin_mask)
# change the threshold to suit the brightness (20-30 gave me best results so far)
_, thresh = cv2.threshold(self.skin_mask, 20, 255, 0)
# Apply gaussian filter on the result to give better result
cv2.GaussianBlur(self.skin_mask, (5, 5), 0, self.skin_mask)
# Trying other types of threshold (all of them didn't work)
# _, thresh = cv2.adaptiveThreshold(skin_mask, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 0, 11, 2)
# _, thresh = cv2.threshold(skin_mask, 0, 255, 0+cv2.THRESH_OTSU) #OTSU Threshold don't give satisfying results
# Multichannel
thresh = cv2.merge((thresh, thresh, thresh))
# Mask the hand from the original frame
self.skin_mask = cv2.bitwise_and(frame, thresh)
# remove faulty skin (kernel of size 9x9)
self.skin_mask = cv2.morphologyEx(self.skin_mask, cv2.MORPH_OPEN, (31, 31), iterations=5)
# reduce black spaces in the hand
cv2.morphologyEx(self.skin_mask, cv2.MORPH_CLOSE, (9, 9), self.skin_mask, iterations=5)
# Draw Skin masking (JFD)
if self.DEBUGGING:
cv2.imshow('skin mask', self.skin_mask)
return self.skin_mask
def run(self, cur_frame, next_frame,):
# Setup the termination criteria, either 10 iteration or move by at least 1 pt
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
new_list_of_objects = []
for obj_tuple in self.list_of_objects:
hsv_roi = None
if len(obj_tuple) == 4:
obj, hsv_roi, n_in_frame, n_not_moving = obj_tuple
if (hsv_roi is not None) and (obj[2] > 0 or obj[3] > 0):
mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
# track in next frame
# backprojection
hsv = cv2.cvtColor(next_frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)
# apply meanshift to get the new location
ret, obj_new = cv2.meanShift(dst, obj, term_crit)
n_in_frame += 1
if PostProcessing.distance_two_squares(obj, obj_new) < 1:
n_not_moving += 1
else:
n_not_moving = 0
x, y, w, h = obj_new
if n_not_moving < 20:
new_list_of_objects.append((obj_new, hsv_roi, n_in_frame, n_not_moving))
# draw
cv2.rectangle(next_frame, (x, y), (x + w, y + h), 255, 2)
self.list_of_objects = new_list_of_objects
pass
def find_content(img_hsv, hist_sample):
""" img hsv, hist_sample as np.array, -> 1 channel distance """
src_img_cp = img_hsv
# normalize the sample histogram
cv2.normalize(hist_sample, hist_sample, 0, 179, cv2.NORM_MINMAX)
distance = cv2.calcBackProject([img_hsv], [0], hist_sample, [0, 180], 0.5)
print('ssssssssssssssssssssss distance -------------------')
# show the distance
ava.cv.utl.show_image_wait_2(distance) # ------------
# convolute with circular, morphology
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
cv2.filter2D(distance, -1, kernel, distance)
print('==================== distance convoluted -------------------')
# show the smoothed distance
ava.cv.utl.show_image_wait_2(distance) # ------------
# threshold
ret, thresh = cv2.threshold(distance, 55, 180, cv2.THRESH_BINARY)
# thresh = cv2.merge([thresh, thresh, thresh])
# do the bitwise_and
#result = cv2.bitwise_and(src_img_cp, thresh)
return thresh
def sliding_window(image,r1,r2,step,roihist):
test_path = "/home/sarbajit/PyCharm_Scripts/test/green_pad_same_name_new/final_rotated2/"
item = image
if item.endswith(".png") or item.endswith(".PNG"):
x = test_path+item
target2 = cv2.imread(x)
target = target2[90:150, 90:520]
(winW, winH) = (50, 30)
for (x, y, window) in sliding_window_test(target,r1,r2,stepSize=step, windowSize=(winW, winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
#this section does the histogram backprojected matching window by window.
hsvt = cv2.cvtColor(window, cv2.COLOR_BGR2HSV)
inputImage = cv2.calcHist([hsvt], [0, 1], None, [180, 256], [0, 180, 0, 256])
cv2.normalize(roihist, roihist, 0, 255, cv2.NORM_MINMAX)
dst = cv2.calcBackProject([hsvt], [0, 1], roihist, [0, 180, 0, 256], 1)
match = cv2.compareHist(roihist, inputImage, method=0)
print match
#the match is printed to see the difference and jumps when the window moves through the landing pad
# THIS IS WHERE YOU WOULD PROCESS YOUR WINDOW,AND DO THE NECESSARY STEPS
# we'll just draw the window and show the results
clone = target.copy()
cv2.rectangle(clone, (x, y), (x + winW, y + winH), (0, 255, 0), 2)
cv2.imshow("window", clone)
cv2.waitKey(1)
time.sleep(1)
# sliding_window('2015-08-06_06-27-48.png',28,58,30)
def _append_boxes_from_meanshift(self, frame, box_all):
"""Adds to the list all bounding boxes found with mean-shift tracking
Mean-shift tracking is used to track objects from frame to frame.
This information is combined with a saliency map to discard
false-positives and focus only on relevant objects that move.
:param frame: current RGB image frame
:box_all: append bounding boxes from tracking to this list
:returns: new list of all collected bounding boxes
"""
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
for i in xrange(len(self.object_roi)):
roi_hist = copy.deepcopy(self.object_roi[i])
box_old = copy.deepcopy(self.object_box[i])
dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)
ret, box_new = cv2.meanShift(dst, tuple(box_old), self.term_crit)
self.object_box[i] = copy.deepcopy(box_new)
# discard boxes that don't move
(xo, yo, wo, ho) = box_old
(xn, yn, wn, hn) = box_new
co = [xo + wo/2, yo + ho/2]
cn = [xn + wn/2, yn + hn/2]
if (co[0]-cn[0])**2 + (co[1]-cn[1])**2 >= self.min_shift2:
box_all.append(box_new)
return box_all
def trackFace(allRoiPts, allRoiHist):
for k in range(0, TRACK):
# read the frame and check if the frame has been read properly
ret, frame = cap.read()
if not ret:
return -1;
break
i=0
# convert the given frame to HSV color space
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# for histogram of each window found, back project them on the current frame and track using CAMSHIFT
for roiHist in allRoiHist:
backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1)
(r, allRoiPts[i]) = cv2.CamShift(backProj, allRoiPts[i], termination)
# error handling for bound exceeding
for j in range(0,4):
if allRoiPts[i][j] < 0:
allRoiPts[i][j] = 0
pts = np.int0(cv2.cv.BoxPoints(r))
# draw bounding box around the new position of the object
cv2.polylines(frame, [pts], True, (0, 255, 255), 2)
i = i + 1
# show the face on the frame
cv2.imshow("Faces", frame)
cv2.waitKey(1)
return 1;
def track(self,im):
im_hsv = cv2.cvtColor(im,cv2.COLOR_BGR2HSV)
track_im = cv2.calcBackProject([im_hsv],[0],self.query_hist,[0,255],1)
track_im_visualize = track_im.copy()
# convert to (x,y,w,h)
track_roi = (self.last_detection[0],self.last_detection[1],self.last_detection[2]-self.last_detection[0],self.last_detection[3]-self.last_detection[1])
# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
# this is done to plot intermediate results of mean shift
for max_iter in range(1,10):
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, max_iter, 1 )
(ret, intermediate_roi) = cv2.CamShift(track_im,track_roi,term_crit)
if max(intermediate_roi) == 0.0 or np.isnan(ret[0]).any() or np.isnan(ret[1]).any() or np.isnan(ret[2]).any():
# expand ROI
track_roi = (int(track_roi[0]),int(track_roi[1]),int(ceil(track_roi[2]*1.2)),int(ceil(track_roi[3]*1.2)))
else:
box = cv2.cv.BoxPoints(ret)
box = np.int0(box)
cv2.drawContours(track_im_visualize,[box],0,max_iter/10.0,2)
if box == None:
self.last_detection = [0,0,frame.shape[0],frame.shape[1]]
else:
self.last_detection = [intermediate_roi[0],intermediate_roi[1],intermediate_roi[0]+intermediate_roi[2],intermediate_roi[1]+intermediate_roi[3]]
self.last_box = box
cv2.imshow("track_win",track_im_visualize)
def track(self, img, center, face_rect, det_face_hsv):
"""
Uses mean shifting to track the users face. Only useful once
a face has already been detected. The Process
1) Convert the image to HSV, since we track with Hue
2) Pull out the Hue values in the detected region, and develop a histogram
3) Create a Back Projection of the initial image with values equal to the
probability of that hue appearing in the facial region
4) Use mean shifting to determine where the new face is
:param img: BGR image from webcam
:param center: tuple giving the normalized center of teh face
:param face_rect: non-normalized dimensions of face rectangle (x, y, cols, rows)
:param det_face_hsv: hsv of the most recently detected face
:return: (new_position, rect)
"""
# convert the original image to hsv, and pull out the face
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
hue_face_hist = cv2.calcHist([det_face_hsv],[0], None, [32], [0, 180])
cv2.normalize(hue_face_hist, hue_face_hist, 0, 255, cv2.NORM_MINMAX)
#calculate teh back projection probabilities
back_proj = cv2.calcBackProject([img_hsv], [0], hue_face_hist, [0, 180], 1)
#track face using meanshift
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
track_box, rect = cv2.meanShift(back_proj, face_rect, term_crit)
#return values
height, width, x = img.shape #rows, cols, depth
new_position = ((rect[0] + rect[2]/2)/float(width), (rect[1] + rect[3]/2)/float(height))
cv2.rectangle(img, (rect[0], rect[1]), (rect[0]+rect[2], rect[1]+rect[3]), 255)
return (new_position, rect)
def rgb_analisis(self, img):
# TODO what happend if the object is lost?
if self.track_window == None:
self.detect_object(img)
if self.track_window == None:
return None
else:
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv], [0], self.hist_track, [0, 180], 1)
# apply meanshift to get the new location
# print dst
# print self.track_window
ret, self.track_window = cv2.CamShift(dst, self.track_window, self.track_crit)
# Draw it on image
pts = cv2.cv.BoxPoints(ret)
pts = np.int0(pts)
cv2.polylines(img, [pts], True, (0, 255, 0), 2)
self.img = img
# cv2.imshow('track',img)
# cv2.waitKey(1)
print "Object tracked"
return self.track_window[0] + self.track_window[2] / 2
def create_image_backprops(images, **kwargs):
"""
"""
pathdir = kwargs.get("path", "")
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
for index, path in images["Path"].items():
rect = images["Crop"][index]
path = os.path.join(pathdir, path)
im_base = open_if_path(path, hsv=True)
im_crop = get_image_crop(im_base, rect)
histogram = cv2.calcHist([im_crop], [0, 1], None, [180, 256], [0, 180, 0, 256])
cv2.normalize(histogram, histogram, 0, 255, cv2.NORM_MINMAX)
backprop = cv2.calcBackProject([im_base], [0, 1], histogram, [0, 180, 0, 256], 1)
cv2.filter2D(backprop, -1, kernel, backprop)
_, im_thresh = cv2.threshold(backprop, 50, 255, 0)
im_mask = cv2.merge((im_thresh, im_thresh, im_thresh))
im_clean = cv2.bitwise_and(im_base, im_mask)
examine = np.vstack([im_base, im_mask, im_clean])
cv2.imshow(path, examine)
while cv2.waitKey(5) != ord(" "):
pass
cv2.destroyAllWindows()
def skin_mask(self, img, det_face_hsv, face_rect):
"""
Create a mask of the image which returns a binary image (black and white) based
on whether we thing a section is skin or not. We do this by analyzing the hue and
saturation from the detected face. From this we can calculate the probability of
any pixel in the full image occuring in the face image. Then we can filter out
any values whose probability is below a certain threshold.
:param img: BGR image from webcam
:param det_face_hsv: hsv image of the face from the previous detection
:param face_rect: non-normalized dimensions of face rectangle (left, top, cols, rows)
:return: 2D array, black and white if pixels are thought to be skin
"""
#Get the HSV images of the whole thing and the face
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
face_left = face_rect[0]
face_top = face_rect[1]
face_width = face_rect[2]
face_height = face_rect[3]
#create a Hue-Saturation histogram of the face
hs_face_hist = cv2.calcHist([det_face_hsv], [0,1], None, [32,32], [0, 180,0, 255])
cv2.normalize(hs_face_hist, hs_face_hist, 0, 255, cv2.NORM_MINMAX)
#create a Hue-Saturation BackProjection, and a mask
#This mask ignores dark pixels < 32, and saturated pixels, <60
hue_min, sat_min, val_min = 0.0, 32.0, 16.0
mask = cv2.inRange(img_hsv, np.array((hue_min, sat_min, val_min)), np.array((180., 255., 255.)))
mask_face = mask[face_top:face_top+face_height, face_left:face_left+face_width]
masked_hs_hist = cv2.calcHist([det_face_hsv], [0,1], mask_face, [32,32], [0, 180,0, 255])
cv2.normalize(masked_hs_hist, masked_hs_hist, 0, 255, cv2.NORM_MINMAX)
masked_hs_prob = cv2.calcBackProject([img_hsv], [0,1], masked_hs_hist, [0, 180,0, 255],1)
cv2.bitwise_and(masked_hs_prob, mask, dst=masked_hs_prob) #seems to lessen noise???
thresh = 8.0 #threshold likelihood for being skin, changes a lot based on setting
_, masked_img = cv2.threshold(masked_hs_prob, thresh, 255, cv2.CV_8U) #throw out below thresh
return masked_img
def do_camshift(vec=0):
global frame, roiBox
# convert the current frame to the HSV color space and perform mean shift
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1)
# apply cam shift to the back projection, convert the points to a bounding box, and then draw them
(r, roiBox) = cv2.CamShift(backProj, roiBox, termination)
pts = np.int0(cv2.boxPoints(r))
cv2.polylines(frame, [pts], True, (0,255,0), 2)
centerScr = get_centerScreen(frame)
x = centerScr[0]
y = centerScr[1]
# print "+" in the center of screen
cv2.line(frame,(x,y-10),(x,y+10),(0,0,255),2) # print line
cv2.line(frame,(x-10,y),(x+10,y),(0,0,255),2) # print line
# cv2.line(frame,(x,y),(x+80,y),(0,255,0),2) # print line
centerRoi = get_centerRoi(pts)
x = centerRoi[0]
y = centerRoi[1]
# print "+" in the center of ROI
cv2.line(frame,(x,y-10),(x,y+10),(0,255,0),2) # print line
cv2.line(frame,(x-10,y),(x+10,y),(0,255,0),2) # print line
gimbel_move(pts,frame,vec)
lineRoiTocenter(centerRoi,centerScr)
print_data(vec)
tragetAcquired(pts)
def scan(self, frame, hsv_frame, mask):
"""Updates all the of trackers for identified objects and updates the searcher which is looking for new objects."""
bproj = cv2.calcBackProject([hsv_frame], [0], self.hist, [0,255], 1)
bproj &= mask
for index, tracker in enumerate(self.tracking):
original_bproj = bproj.copy()
box, bproj, split = tracker.update(bproj)
coords, dims, theta = box
w,h = dims
if split:
self.splitTracker(tracker)
del self.tracking[index]
bproj = original_bproj
if tracker.hasFound() and w > 0 and h > 0:
cv2.ellipse(frame, box, self.averageColor, 2)
else:
del self.tracking[index]
box, bproj, split = self.searcher.update(bproj.copy())
if split:
self.splitTracker(self.searcher)
self.searcher = Tracker(self.frameDims, self.full_track_window, found = False)
if self.searcher.hasFound(): # If searcher finds an object, start tracking that object and make a new searcher
self.tracking.append(self.searcher)
self.searcher = Tracker(self.frameDims, self.full_track_window, found = False)
return frame
def frame_track(self, cur_frame):
vis = cur_frame.copy()
hsv = cv2.cvtColor(cur_frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.)))
prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1)
prob &= mask
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
# get rotated bounding box
track_box, self.track_window = cv2.CamShift(prob, self.track_window, term_crit)
# get bounding box
track_rect_rotate = cv2.boxPoints(track_box)
# get rectangle
track_rect = cv2.boundingRect(track_rect_rotate)
# store them in yaml compatible format
track_rect_yaml=track_rect
if self.show_backproj:
vis[:] = prob[...,np.newaxis]
pt1 = (track_rect_yaml[0],track_rect_yaml[1])
pt2 = (track_rect_yaml[0] + track_rect_yaml[2], track_rect_yaml[1] + track_rect_yaml[3])
cv2.rectangle(vis, pt1, pt2, (0, 255, 0), 2)
cv2.ellipse(vis, track_box, (0, 0, 255), 2)
self.add_frame_to_dataset_based_on_difference(cur_frame, track_rect_yaml)
return vis
def Background_remove(img_trimmed,sample_path):
roi = cv2.imread(sample_path)
hsv = cv2.cvtColor(roi,cv2.COLOR_BGR2HSV)
target = img_trimmed
hsvt = cv2.cvtColor(target,cv2.COLOR_BGR2HSV)
# calculating object histogram
roihist = cv2.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )
# normalize histogram and apply backprojection
cv2.normalize(roihist,roihist,0,255,cv2.NORM_MINMAX)
dst = cv2.calcBackProject([hsvt],[0,1],roihist,[0,180,0,256],1)
# Now convolute with circular disc
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
cv2.filter2D(dst,-1,disc,dst)
# threshold and binary AND
ret,thresh = cv2.threshold(dst,5,255,0)
#invert to get the object of interest
cv2.bitwise_not(thresh,thresh)
thresh = cv2.merge((thresh,thresh,thresh))
res = cv2.bitwise_and(target,thresh)
#res = np.vstack((target,thresh,res))
return res
def apply_skin_mask(self, frame):
# transform from rgb to hsv
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# detect skin using the hand histogram
self.skin_mask = cv2.calcBackProject([hsv], [0, 1], self.hand_histogram, [0, 180, 0, 256], 1)
# create a elliptical kernel (11 is the best in my case)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))
cv2.filter2D(self.skin_mask, -1, kernel, self.skin_mask)
# Apply gaussian filter to give much better result
cv2.GaussianBlur(self.skin_mask, (3, 3), 0, self.skin_mask)
# change the threshold to suit the brightness (20-30 gave me best results so far)
_, thresh = cv2.threshold(self.skin_mask, 20, 255, 0)
thresh = cv2.merge((thresh, thresh, thresh))
# Mask the hand from the original frame
self.skin_mask = cv2.bitwise_and(frame, thresh)
# Apply gaussian filter to give much cleaner result
cv2.GaussianBlur(self.skin_mask, (5, 5), 0, self.skin_mask)
# remove faulty skin (kernel of size 9x9)
cv2.morphologyEx(self.skin_mask, cv2.MORPH_OPEN, (31, 31), self.skin_mask, iterations=5)
# reduce black holes in the hand
cv2.morphologyEx(self.skin_mask, cv2.MORPH_CLOSE, (9, 9), self.skin_mask, iterations=5)
# Show skin detection result if DEBUGGING
if self.DEBUGGING:
cv2.imshow('SKIN', self.skin_mask)
return self.skin_mask
def main():
cap = cv2.VideoCapture(0) # カメラのキャプチャー
ret,im = cap.read() # 最初のフレームを取得
r,h,c,w = 200,50,400,50 # 追跡したい領域の初期設定
h0 = 0
roi = im[r:r+h, c:c+w] # 追跡のためのROIを設定
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # HSV色空間に変換
mask = cv2.inRange(hsv_roi, np.array((0, 60,32)), np.array((180,255,255))) # マスク画像の作成
roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180]) # ヒストグラムの計算
cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX) # ヒストグラムの正規化
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 ) # 終了基準の設定
while(1):
ret ,im = cap.read()
hsv = cv2.cvtColor(im, cv2.COLOR_BGR2HSV) # HSV色空間に変換
dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1) # バックプロジェクションの計算
cv2.setMouseCallback("CamShift",onMouse) # マウスイベント
# 左クリックされた場合
if(cx!=0):
(c,r,w,h) = (cx-25, cy-25, 50, 50)
track_window = (c,r,w,h)
ret, track_window = cv2.CamShift(dst, track_window, term_crit) # 新しい場所を取得するためにcamshiftを適用
(x,y,w,h) = track_window
frame = cv2.rectangle(im, (x,y), (x+w,y+h),(0,0,200),2) # 追跡している領域の表示
cv2.circle(im,(cx,cy),10,(220,0,0), -1) # 左クリックした場所を円で表示
cv2.imshow("CamShift",im) # 映像の表示
# 任意のキーが押されたら終了
if cv2.waitKey(10) > 0:
cap.release()
cv2.destroyAllWindows()
break
def main():
memory = ALProxy("ALMemory", NAO_IP, NAO_PORT)
basicVideoProcessing = BasicVideoProcessing()
basicVideoProcessing.connectToCamera()
track = (0,0,0,0)
term = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
try:
while True:
img = basicVideoProcessing.getImageFromCamera()
if (img == None):
print "Img is empty"
break
else:
if basicVideoProcessing.isWindowEmpty(track):
track = basicVideoProcessing.setWindowAsFrameSize(img )
else:
center = retn[1]
memory.raiseEvent("RedBallDetectedEvent", (640-center[0], 480-center[1]))
hsv_w = cv2.cvtColor(img,cv2.COLOR_BGR2HSV)
#mask1 = cv2.inRange(hsv_w, (0,204,138), (3,210,254))
#mask2 = cv2.inRange(hsv_w, (171,173,51), (176,209,77))
acmask = cv2.inRange(hsv_w, np.array([110,125,61]), np.array([144,156,136]))
acmask = cv2.erode(acmask, None, iterations=1)
acmask = cv2.dilate(acmask, None, iterations=1)
hist = cv2.calcHist([hsv_w],[0,1],acmask,[180,255],[0,180,0,255])
cv2.normalize(hist,hist,0,255,cv2.NORM_MINMAX)
dst = cv2.calcBackProject([hsv_w],[0,1],hist,[0,180,0,255],1)
retn, track = cv2.CamShift(dst, track, term)
except BaseException, err:
print "Undefined error: " + str(err)
def run_main():
cap = cv2.VideoCapture('test.mp4')
ret, frame = cap.read()
c,r,w,h = 200,250,70,70
track_window = (c,r,w,h)
roi = frame[r:r+h, c:c+w]
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 30.,32.)), np.array((180.,255.,255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 80, 1)
while True:
ret, frame = cap.read()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv], [0], roi_hist, [0,180], 1)
ret, track_window = cv2.meanShift(dst, track_window, term_crit)
x,y,w,h = track_window
# print track_window
cv2.rectangle(frame, (x,y), (x+w,y+h), 255, 2)
cv2.putText(frame, 'Tracked', (x-25,y-10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 2)
cv2.imshow('Tracking', frame)
if cv2.waitKey(1) & 0xFF == ord('q'): break
cap.release()
cv2.destroyAllWindows()
def find_center(self,im):
'''actually do the tracking!'''
im_hsv = cv2.cvtColor(im,cv2.COLOR_BGR2HSV)
track_im = cv2.calcBackProject([im_hsv],[0],self.query_hist,[0,255],1)
track_im_visualize = track_im.copy()
# convert to (x,y,w,h)
track_roi = (self.last_detection[0],self.last_detection[1],self.last_detection[2]-self.last_detection[0],self.last_detection[3]-self.last_detection[1])
# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
# this is done to plot intermediate results of mean shift
for max_iter in range(1,10):
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, max_iter, 1 )
(ret, intermediate_roi) = cv2.meanShift(track_im,track_roi,term_crit)
cv2.rectangle(track_im_visualize,(intermediate_roi[0],intermediate_roi[1]),(intermediate_roi[0]+intermediate_roi[2],intermediate_roi[1]+intermediate_roi[3]),max_iter/10.0,2)
self.last_detection = [intermediate_roi[0],intermediate_roi[1],intermediate_roi[0]+intermediate_roi[2],intermediate_roi[1]+intermediate_roi[3]]
# update_hist = True
# if update_hist:
# self.query_img = im
# self.query_roi = intermediate_roi
# self.get_query_histogram()
#get the center of the box
posX = (self.last_detection[0]+self.last_detection[2])/2
posY = (self.last_detection[1]+self.last_detection[3])/2
cv2.circle(im,(posX,posY),2,(255,0,0),10)
cv2.imshow('image',im)
cv2.rectangle(self.query_img,(self.query_roi[0],self.query_roi[1]),(self.query_roi[0]+self.query_roi[2],self.query_roi[1]+self.query_roi[3]),1.0,2)
cv2.imshow('query_img',self.query_img)
cv2.waitKey(20)
return Target(x = posX, y = posY, x_img_size = self.query_img.shape[0],y_img_size = self.query_img.shape[1])
def face_track(self):
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_AUTOFOCUS, 0)
roi_hist = None
t = 0
while (True):
ret, frame = cap.read()
if ret == False:
break
if roi_hist is None:
if t == 3:
roiPts, num_face = self.detect_face(frame)
if num_face != 0:
roi = frame[roiPts[1]:roiPts[1] + roiPts[3],
roiPts[0]:roiPts[0] + roiPts[2]]
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
roi_hist = cv2.calcHist([hsv_roi], [0, 1], None,
[180, 256], [0, 180, 0, 256])
cv2.normalize(roi_hist, roi_hist, 0, 255,
cv2.NORM_MINMAX)
t = 0
else:
t += 1
else: # Face Track On
# CamShift
self.face_x = roiPts[0] + roiPts[2] / 2
for i, sect in enumerate(self.face_section):
if self.face_x >= sect and self.face_x <= self.face_section[
i + 1]:
# self.current_face_section = i
self.set_face_section(i)
break
# print(f"x:{self.face_x}")
print(self.current_face_section)
roi_w = roiPts[2]
roi_h = roiPts[3]
scaled_roi_w = int(roi_w * 1.5)
scaled_roi_h = int(roi_h * 1.5)
n_x = int(roiPts[0] - 0.25 * roi_w)
n_y = int(roiPts[1] - 0.25 * roi_h)
if n_x < 0:
n_x = 0
if n_y < 0:
n_y = 0
if n_x + scaled_roi_w > 1280:
n_x_2 = 1280
else:
n_x_2 = n_x + scaled_roi_w
if n_y + scaled_roi_h > 720:
n_y_2 = 720
else:
n_y_2 = n_y + scaled_roi_h
scaled_roiPts = [n_x, n_y, n_x_2, n_y_2]
# Change to HSV Colour
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# Histogram BackProjection
dst = cv2.calcBackProject([hsv], [0, 1], roi_hist,
[0, 180, 0, 256], 1)
roiPts = [n_x, n_y, scaled_roi_w, scaled_roi_h]
ret, roiPts = cv2.CamShift(dst, roiPts, term_crit)
pts = cv2.boxPoints(ret)
pts = np.int0(pts)
if self.pts_in_area(pts, area) is False:
roi_hist = None
t = 0
face_x = -1
self.set_face_section(0)
# else:
# cv2.polylines(frame, [pts], True, (0,255,255), 2)
# cv2.imshow('frame', frame)
k = cv2.waitKey(60) & 0xff
if k == ord('q'):
break
cv2.destroyAllWindows()
cap.release()
return
img_hsv = cv.cvtColor(img_color, cv.COLOR_BGR2HSV)
img_ROI = img_hsv[start_y:end_y, start_x:end_x]
cv.imshow("ROI", img_ROI)
objectHistogram = cv.calcHist([img_ROI], [0], None, [180], (0, 180))
cv.normalize(objectHistogram,
objectHistogram,
alpha=0,
beta=255,
norm_type=cv.NORM_MINMAX)
step = step + 1
elif step == 4:
img_hsv = cv.cvtColor(img_color, cv.COLOR_BGR2HSV)
bp = cv.calcBackProject([img_hsv], [0], objectHistogram, [0, 180], 1)
rotatedRect, track_window = cv.CamShift(
bp, track_window,
(cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1))
# 오브젝트 위치에 빨간색 타원을 그려줌
cv.ellipse(img_color, rotatedRect, (0, 0, 255), 2)
pts = cv.boxPoints(rotatedRect)
pts = np.int0(pts)
for i in range(4):
cv.line(img_color, tuple(pts[i]), tuple(pts[(i + 1) % 4]),
(0, 255, 0), 2)
cv.imshow('color', img_color)
"""录制新的手势（训练集）"""
# saveImg = not saveImg # True
if gesturename != '': #
saveImg = True
else:
print("Enter a gesture group name first, by enter press 'n'! ")
saveImg = False
elif key == ord('n'):
# 开始录制新手势
# 首先输入文件夹名字
gesturename = (input("enter the gesture folder name: "))
os.makedirs(gesturename)
path = "./" + gesturename + "/" # 生成文件夹的地址 用来存放录制的手势
if search_model == True:
frame_copy = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
dst = cv.calcBackProject([frame_copy], [0, 1, 2], hist,
[0, 180, 0, 256, 0, 256], 1)
cv.imshow('frame2', dst)
#展示处理之后的视频帧
cv.imshow('frame', frame)
#ROI显示
cv.imshow("ROI", frame[y0:y0 + height, x0:x0 + width])
#最后记得释放捕捉
cap.release()
cv.destroyAllWindows()
#工具函数
# 显示ROI为二值模式
# 图像的二值化，就是将图像上的像素点的灰度值设置为0或255，
# 也就是将整个图像呈现出明显的只有黑和白的视觉效果。
import cv2
import numpy as np
#1
src = cv2.imread('../lena.jpg')
hsv = cv2.cvtColor(src, cv2.COLOR_BGR2HSV)
h, s, v = cv2.split(hsv)
#2
roi = cv2.selectROI(src)
print('roi=', roi)
roi_h = h[roi[1]:roi[1] + roi[3], roi[0]:roi[0] + roi[2]]
hist = cv2.calcHist([roi_h], [0], None, [64], [0, 256])
backP = cv2.calcBackProject([h.astype(np.float32)], [0],
hist, [0, 256],
scale=1.0)
#3
hist = cv2.sort(hist, cv2.SORT_EVERY_COLUMN + cv2.SORT_DESCENDING)
k = 1
T = hist[k][0] - 1
print('T=', T)
ret, dst = cv2.threshold(backP, T, 255, cv2.THRESH_BINARY)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()
def camShiftTracking(self, roi, roiMask, image, imageStream, trackWindow):
# Termination criteria
termCrit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 3, 1)
self.trackWindow = trackWindow
roiHSV = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
# Histogram backprojection
roiHist = cv2.calcHist([roiHSV], [0], roiMask, [16], [0, 180])
roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX)
# initial error is zero (frames where tarps are not detected)
error = 0
while error < 8:
# Get the next image in the image stream
ret, image = imageStream.read()
# Check to see if image is not NoneType
if ret == True:
# Get the HSV image
imageHSV = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([imageHSV], [0], roiHist, [0, 180],
1)
# Find new tracking window
ret, self.trackWindow = cv2.CamShift(dst, self.trackWindow,
termCrit)
points = cv2.boxPoints(ret)
points = np.int0(points)
if points[0] is [0, 0]:
continue
imageCAMShift = cv2.polylines(image, [points], True, 255, 1)
# New window of analysis
windowOfAnalysis = self.getWindow(points)
# Define new region of interest
roiNew = image[windowOfAnalysis[2]:windowOfAnalysis[3],
windowOfAnalysis[0]:windowOfAnalysis[1]]
# check if tarps are found
tarpsFound = self.findTarps(image, roiNew, windowOfAnalysis)
# Updating error count
if not tarpsFound:
error += 1
else:
cv2.imshow("image", image)
if error > 0:
error -= 1
else:
error += 1
if error == 4:
break
if cv2.waitKey(1) & 0xFF is 27:
break
def predictor():
global prediction
cam = cv2.VideoCapture(1)
if cam.read()[0] == False:
cam = cv2.VideoCapture(0)
hist = grid()
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))
dst = cv2.filter2D(dst,-1,disc,dst)
blur = cv2.GaussianBlur(dst, (11,11), 0)
blur = cv2.medianBlur(blur, 15)
#blur = cv2.bilateralFilter(blur, 9, 75, 75)
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]
# kernel = np.ones((3, 3), np.uint8)
# opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations = 2)
# #sure background area
# sureBackground = cv2.dilate(opening, kernel, iterations = 3)
# #sure foreground area
# distanceTransform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
# _, sureForeground = cv2.threshold(distanceTransform, 0.7 * distanceTransform.max(), 255, 0)
# #unknown region
# sureForeground = np.uint8(sureForeground)
# unknown = cv2.subtract(sureBackground, sureForeground)
# known = cv2.subtract(sureForeground, sureBackground)
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_probability, pred_class = probability(model, save_img)
if pred_probability * 100 > 80:
text = class_from_db(pred_class)
print(text)
board = np.zeros((480, 640, 3), dtype = np.uint8)
arr = split_to_array(text, 2)
print_text(board, arr)
cv2.rectangle(img, (x, y), (x + w, y + h), (255, 255, 0), 2)
res = np.hstack((img, board))
cv2.imshow("recognizing gesture...", res)
cv2.imshow("thresh", thresh)
if cv2.waitKey(1) == ord('q'):
break
def recognize():
global prediction
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]
contours = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[1]
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)
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)
cv2.imshow("thresh", thresh)
if cv2.waitKey(1) == ord('q'):
break
# Read a new frame
ok, frame = video.read()
if not ok:
break
# Start timer
timer = cv2.getTickCount()
frame = cv2.resize(frame, (video_w, video_h))
frame2 = frame.copy()
# -------- meanshift -------------
hsv_frame = cv2.cvtColor(frame.copy(), cv2.COLOR_BGR2HSV)
mean_dst = cv2.calcBackProject([hsv_frame], [0], roi_hist, [0, 180], 1)
cv2.imshow('mean_dst', mean_dst)
# apply meanshift to get the new location
ret, track_window = cv2.meanShift(mean_dst, track_window, term_crit)
# Draw it on image
xm, ym, wm, hm = track_window
cv2.rectangle(frame, (xm, ym), (xm + wm, ym + hm), (0, 255, 255), 2, 1)
# -------- meanshift end ---------
# -------- fgbg ------------------
# frame2 = cv2.GaussianBlur(frame2, (3, 3), 0)
#
def get_hand_hist():
cam = cv2.VideoCapture(1)
if cam.read()[0] == False:
cam = cv2.VideoCapture(0)
x, y, w, h = 300, 100, 300, 300
flagPressedC, flagPressedS, flagPressedQ = False, False, False
# img切割的範圍
imgCrop = None
while True:
# 搜尋目標圖片
img = cam.read()[1]
img = cv2.flip(img, 1)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
cv2.imshow("hsv", hsv)
keypress = cv2.waitKey(1)
if keypress == ord('c'):
# 擷取imgCrop圖片的HSV
hsvCrop = cv2.cvtColor(imgCrop, cv2.COLOR_BGR2HSV)
# print(hsvCrop.shape)
flagPressedC = True
# region cv2.calcHist用法
# cv2.calcHist(images, channels, mask, histSize, ranges)
# imaages：要分析的圖片檔
# channels：產生的直方圖類型。例：[0]→灰階，[0, 1, 2]→RGB三色。
# mask：optional，若有提供則僅計算mask的部份。
# histSize：要切分的像素強度值範圍，預設為256。每個channel皆可指定一個範圍。例如，[32,32,32] 表示RGB三個channels皆切分為32區段。
# ranges：X軸(像素強度)的範圍，預設為[0,256]（非筆誤，calcHist函式的要求，最後那個值是表示<256）。
# endregion
# 用hsvCrop抓取所需的直方圖範圍，藉此追蹤手部
hist = cv2.calcHist([hsvCrop], [0, 1], None, [60, 140],
[0, 180, 0, 256])
# hist = cv2.calcHist([hsvCrop], [0, 1], None, [180, 256], [0, 180, 0, 256]) origin
# 正規化 結果在0~1之間
cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)
elif keypress == ord('s'):
flagPressedS = True
break
elif keypress == ord('q'):
flagPressedQ = True
break
if flagPressedC:
# 直方圖反向投影 利用直方圖顯示感興趣的區塊
dst = cv2.calcBackProject([hsv], [0, 1], hist, [0, 180, 0, 256], 1)
cv2.imshow("dst", dst)
# 複製
dst1 = dst.copy()
# 定義結構元素
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (14, 14))
# disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(10,10)) origin
# region cv2.filter2D用法
# cv2.filter2D(src, ddepth, kernel, dst, anchor)
# src：輸入圖。
# dst：輸出圖，和輸入圖的尺寸、通道數相同。
# ddepth：輸出圖深度。
# kernel：使用的核心。
# anchor：錨點，預設為核心中央
# endregion
# 濾波(filtering) 提取感興趣的視覺特徵
cv2.filter2D(dst, -1, disc, dst)
# 高斯模糊
blur = cv2.GaussianBlur(dst, (15, 15), 0)
cv2.imshow("blur", blur)
# 中位數模糊
blur = cv2.medianBlur(blur, 15)
# 二值化
ret, thresh = cv2.threshold(blur, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
# 將 "多個單通道" 圖像合併成 "一個多通道圖像"
thresh = cv2.merge((thresh, thresh, thresh))
cv2.imshow("Thresh", thresh)
if not flagPressedS:
imgCrop = build_squares(img)
cv2.imshow("Set hand histogram", img)
cam.release()
cv2.destroyAllWindows()
# 開啟一個檔名"hist"的檔案
if not flagPressedQ:
with open("hist", "wb") as f:
# 將"hist"寫入
pickle.dump(hist, f)
def get_hand_hist():
cam = cv2.VideoCapture(0)
host = "192.168.0.77:8080"
if len(sys.argv) > 1:
host = sys.argv[1]
hoststr = 'http://' + host + '/video'
print('Streaming ' + hoststr)
stream = urllib.request.urlopen(hoststr)
bytes = b''
x, y, w, h = 300, 100, 300, 300
flagPressedC, flagPressedS = False, False
imgCrop = None
while True:
bytes += stream.read(1024)
a_temp = b'\xff\xd8'
b_temp = b'\xff\xd9'
a = bytes.find(a_temp)
b = bytes.find(b_temp)
if a != -1 and b != -1:
jpg = bytes[a:b + 2]
bytes = bytes[b + 2:]
img = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),
cv2.IMREAD_COLOR)
img = cv2.resize(img, (640, 480))
#img = cam.read()[1]
img = cv2.flip(img, 1)
height, width = img.shape[:2]
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
keypress = cv2.waitKey(1)
if keypress == ord('c'):
hsvCrop = cv2.cvtColor(imgCrop, cv2.COLOR_BGR2HSV)
flagPressedC = True
hist = cv2.calcHist([hsvCrop], [0, 1], None, [180, 256],
[0, 180, 0, 256])
cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)
elif keypress == ord('s'):
flagPressedS = True
break
if flagPressedC:
dst = cv2.calcBackProject([hsv], [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)
ret, thresh = cv2.threshold(
blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
thresh = cv2.merge((thresh, thresh, thresh))
res = cv2.bitwise_and(img, thresh)
#cv2.imshow("res", res)
cv2.imshow("Thresh", thresh)
if not flagPressedS:
imgCrop = build_squares(img)
#cv2.rectangle(img, (x,y), (x+w, y+h), (0,255,0), 2)
cv2.imshow("Set hand histogram", img)
cam.release()
cv2.destroyAllWindows()
with open("hist", "wb") as f:
pickle.dump(hist, f)
def __init__(self, queue):
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-v",
"--video",
help="path to the (optional) video file")
args = vars(ap.parse_args())
# grab the reference to the current frame, list of ROI
# points and whether or not it is ROI selection mode
self.frame = None
self.roiPts1 = []
self.roiPts2 = []
self.inputMode = False
self.Detect = False
self.MedQueueX1 = collections.deque([])
self.MedQueueX2 = collections.deque([])
self.MedQueueY1 = collections.deque([])
self.MedQueueY2 = collections.deque([])
self.MedNum = 50
# if the video path was not supplied, grab the reference to the
# camera
if not args.get("video", False):
camera = cv2.VideoCapture(0)
# otherwise, load the video
else:
camera = cv2.VideoCapture(args["video"])
# setup the mouse callback
cv2.namedWindow("frame")
#cv2.setMouseCallback("frame", self.selectROI)
# initialize the termination criteria for cam shift, indicating
# a maximum of ten iterations or movement by a least one pixel
# along with the bounding box of the ROI
termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 20, 1)
roiBox1 = None
roiBox2 = None
# keep looping over the frames
while True:
# grab the current frame
(grabbed, self.frame) = camera.read()
# check to see if we have reached the end of the
# video
if not grabbed:
break
# if the see if the ROI has been computed
if roiBox1 is not None and roiBox2 is not None:
# convert the current frame to the HSV color space
# and perform mean shift
hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV)
backProj1 = cv2.calcBackProject([hsv], [1], roiHist1,
[140, 256], 1)
backProj2 = cv2.calcBackProject([hsv], [1], roiHist2,
[140, 256], 1)
# apply cam shift to the back projection, convert the
# points to a bounding box, and then draw them
(r1, roiBox1) = cv2.CamShift(backProj1, roiBox1, termination)
(r2, roiBox2) = cv2.CamShift(backProj2, roiBox2, termination)
pts1 = np.int0(cv2.boxPoints(r1))
pts2 = np.int0(cv2.boxPoints(r2))
cv2.polylines(self.frame, [pts1], True, (0, 255, 0), 2)
cv2.polylines(self.frame, [pts2], True, (0, 255, 0), 2)
center_x1 = (pts1[0][0] + pts1[1][0] + pts1[2][0] +
pts1[3][0]) / 4
center_y1 = (pts1[0][1] + pts1[1][1] + pts1[2][1] +
pts1[3][1]) / 4
center_x2 = (pts2[0][0] + pts2[1][0] + pts2[2][0] +
pts2[3][0]) / 4
center_y2 = (pts2[0][1] + pts2[1][1] + pts2[2][1] +
pts2[3][1]) / 4
if len(self.MedQueueX1) == self.MedNum:
self.MedQueueX1.popleft()
self.MedQueueX2.popleft()
self.MedQueueY1.popleft()
self.MedQueueY2.popleft()
self.MedQueueX1.append(center_x1)
self.MedQueueX2.append(center_x2)
self.MedQueueY1.append(center_y1)
self.MedQueueY2.append(center_y2)
if len(self.MedQueueX1) > 0:
med_x1 = np.median(self.MedQueueX1)
med_x2 = np.median(self.MedQueueX2)
med_y1 = np.median(self.MedQueueY1)
med_y2 = np.median(self.MedQueueY2)
queue.put((1, med_x1, med_y1))
queue.put((2, med_x2, med_y2))
print("CamShift Player 1 X is %d, Y is %d" %
(center_x1, center_y1))
print("CamShift Player 2 X is %d, Y is %d" %
(center_x2, center_y2))
# show the frame and record if the user presses a key
key = cv2.waitKey(1) & 0xFF
cv2.imshow("frame", self.frame)
if not self.Detect:
orig = self.frame.copy()
#cv2.imshow("frame", self.frame)
x, y, r = self.detection(self.frame)
if not (r == []):
# The condition states that we wait until exactly 2 players are found.
# Built the range of interest(roi) as the square that blocks the Hough circle.
self.roiPts1 = [(int(x[0] - r[0]), int(y[0] - r[0])),
(int(x[0] + r[0]), int(y[0] - r[0])),
(int(x[0] - r[0]), int(y[0] + r[0])),
(int(x[0] + r[0]), int(y[0] + r[0]))]
self.roiPts2 = [(int(x[1] - r[1]), int(y[1] - r[1])),
(int(x[1] + r[1]), int(y[1] - r[1])),
(int(x[1] - r[1]), int(y[1] + r[1])),
(int(x[1] + r[1]), int(y[1] + r[1]))]
self.roiPts1 = np.array(self.roiPts1)
self.roiPts2 = np.array(self.roiPts2)
# maxY = np.shape(orig)(3)
self.roiPts1[self.roiPts1 < 0] = 0
self.roiPts2[self.roiPts2 < 0] = 0
# self.roiPts1[self.roiPts1 > maxY] = maxY
# self.roiPts2[self.roiPts2 > maxY] = maxY
print("ROI PTS")
print(self.roiPts1)
print(self.roiPts2)
s1 = self.roiPts1.sum(axis=1)
s2 = self.roiPts2.sum(axis=1)
tl1 = self.roiPts1[np.argmin(s1)]
tl2 = self.roiPts2[np.argmin(s2)]
br1 = self.roiPts1[np.argmax(s1)]
br2 = self.roiPts2[np.argmax(s2)]
# grab the ROI for the bounding box and convert it
# to the HSV color space
roi1 = orig[tl1[1]:br1[1], tl1[0]:br1[0]]
roi1 = cv2.cvtColor(roi1, cv2.COLOR_BGR2HSV)
roi2 = orig[tl2[1]:br2[1], tl2[0]:br2[0]]
roi2 = cv2.cvtColor(roi2, cv2.COLOR_BGR2HSV)
print("ROI1")
print(roi1)
print("ROI2")
print(roi2)
# compute a HSV histogram for the ROI and store the
# bounding box
roiHist1 = cv2.calcHist([roi1], [1], None, [256],
[140, 255], False)
roiHist1 = cv2.normalize(roiHist1, roiHist1, 0, 255,
cv2.NORM_MINMAX)
roiBox1 = (tl1[0], tl1[1], br1[0], br1[1])
roiHist2 = cv2.calcHist([roi2], [1], None, [256],
[140, 255], False)
roiHist2 = cv2.normalize(roiHist2, roiHist2, 0, 255,
cv2.NORM_MINMAX)
roiBox2 = (tl2[0], tl2[1], br2[0], br2[1])
self.Detect = True
# if the 'q' key is pressed, stop the loop
elif key == ord("q"):
break
#queue.put((0,0,0))
# cleanup the camera and close any open windows
camera.release()
cv2.destroyAllWindows()
import cv2
import numpy as np
roi = cv2.imread('federerElem.jpg')
print(roi.shape)
hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
target = cv2.imread('federer_resize.jpg')
hsvt = cv2.cvtColor(target, cv2.COLOR_BGR2HSV)
# calculating object histogram
roihist = cv2.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256])
# normalize histogram and apply backprojection
cv2.normalize(roihist, roihist, 0, 255, cv2.NORM_MINMAX)
dst = cv2.calcBackProject([hsvt], [0, 1], roihist, [0, 180, 0, 256], 1)
# Now convolute with circular disc
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
cv2.filter2D(dst, -1, disc, dst)
# threshold and binary AND
ret, thresh = cv2.threshold(dst, 50, 255, 0)
thresh = cv2.merge((thresh, thresh, thresh))
res = cv2.bitwise_and(target, thresh)
res = np.vstack((target, thresh, res))
#cv2.imwrite('res.jpg',res)
cv2.imshow('res', res)
cv2.imshow('Elemnt', roi)
cv2.waitKey(0)
def main(args):
#Clean previous image
clean_images()
#Training phase
model = training()
vidcap = cv2.VideoCapture(args.file_name)
fps = vidcap.get(cv2.CAP_PROP_FPS)
width = vidcap.get(3) # float
height = vidcap.get(4) # float
# Define the codec and create VideoWriter object
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter(dir_path + "\outputs\output.avi", fourcc, fps,
(640, 480))
# initialize the termination criteria for cam shift, indicating
# a maximum of ten iterations or movement by a least one pixel
# along with the bounding box of the ROI
termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
roiBox = None
roiHist = None
success = True
similitary_contour_with_circle = 0.65 # parameter
count = 0
current_sign = None
current_text = ""
current_size = 0
sign_count = 0
coordinates = []
position = []
file = open(dir_path + "\Output.txt", "w")
try:
while True:
success, frame = vidcap.read()
if not success:
print("FINISHED")
break
width = frame.shape[1]
height = frame.shape[0]
#frame = cv2.resize(frame, (640,int(height/(width/640))))
frame = cv2.resize(frame, (640, 480))
print("Frame:{}".format(count))
#image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
coordinate, image, sign_type, text = localization(
frame, args.min_size_components,
args.similitary_contour_with_circle, model, count,
current_sign)
if coordinate is not None:
cv2.rectangle(image, coordinate[0], coordinate[1],
(255, 255, 255), 1)
print("Sign:{}".format(sign_type))
if sign_type > 0 and (not current_sign
or sign_type != current_sign):
current_sign = sign_type
current_text = text
# top = int(coordinate[0][1]*1.05)
# left = int(coordinate[0][0]*1.05)
# bottom = int(coordinate[1][1]*0.95)
# right = int(coordinate[1][0]*0.95)
top = int(coordinate[0][1])
left = int(coordinate[0][0])
bottom = int(coordinate[1][1])
right = int(coordinate[1][0])
position = [
count, sign_type if sign_type <= 8 else 8,
coordinate[0][0], coordinate[0][1], coordinate[1][0],
coordinate[1][1]
]
cv2.rectangle(image, coordinate[0], coordinate[1], (0, 255, 0),
1)
font = cv2.FONT_HERSHEY_PLAIN
cv2.putText(image, text,
(coordinate[0][0], coordinate[0][1] - 15), font, 1,
(0, 0, 255), 2, cv2.LINE_4)
tl = [left, top]
br = [right, bottom]
print(tl, br)
current_size = math.sqrt(
math.pow((tl[0] - br[0]), 2) +
math.pow((tl[1] - br[1]), 2))
# grab the ROI for the bounding box and convert it
# to the HSV color space
roi = frame[tl[1]:br[1], tl[0]:br[0]]
print(roi)
roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
#roi = cv2.cvtColor(roi, cv2.COLOR_BGR2LAB)
# compute a HSV histogram for the ROI and store the
# bounding box
roiHist = cv2.calcHist([roi], [0], None, [16], [0, 180])
roiHist = cv2.normalize(roiHist, roiHist, 0, 255,
cv2.NORM_MINMAX)
roiBox = (tl[0], tl[1], br[0], br[1])
elif current_sign:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180],
1)
# apply cam shift to the back projection, convert the
# points to a bounding box, and then draw them
(r, roiBox) = cv2.CamShift(backProj, roiBox, termination)
pts = np.int0(cv2.boxPoints(r))
s = pts.sum(axis=1)
tl = pts[np.argmin(s)]
br = pts[np.argmax(s)]
size = math.sqrt(
pow((tl[0] - br[0]), 2) + pow((tl[1] - br[1]), 2))
print(size)
if current_size < 1 or size < 1 or size / current_size > 30 or math.fabs(
(tl[0] - br[0]) / (tl[1] - br[1])) > 2 or math.fabs(
(tl[0] - br[0]) / (tl[1] - br[1])) < 0.5:
current_sign = None
print("Stop tracking")
else:
current_size = size
if sign_type > 0:
top = int(coordinate[0][1])
left = int(coordinate[0][0])
bottom = int(coordinate[1][1])
right = int(coordinate[1][0])
position = [
count, sign_type if sign_type <= 8 else 8, left, top,
right, bottom
]
cv2.rectangle(image, coordinate[0], coordinate[1],
(0, 255, 0), 1)
font = cv2.FONT_HERSHEY_PLAIN
cv2.putText(image, text,
(coordinate[0][0], coordinate[0][1] - 15),
font, 1, (0, 0, 255), 2, cv2.LINE_4)
elif current_sign:
position = [
count, sign_type if sign_type <= 8 else 8, tl[0],
tl[1], br[0], br[1]
]
cv2.rectangle(image, (tl[0], tl[1]), (br[0], br[1]),
(0, 255, 0), 1)
font = cv2.FONT_HERSHEY_PLAIN
cv2.putText(image, current_text, (tl[0], tl[1] - 15), font,
1, (0, 0, 255), 2, cv2.LINE_4)
if current_sign:
sign_count += 1
coordinates.append(position)
cv2.imshow('Result', image)
count = count + 1
#Write to video
out.write(image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
except Exception as e:
traceback.print_exc()
print(e)
file.write("{}".format(sign_count))
for pos in coordinates:
file.write("\n{} {} {} {} {} {}".format(pos[0], pos[1], pos[2], pos[3],
pos[4], pos[5]))
print("Finish {} frames".format(count))
file.close()
# ff = FFmpeg(
# inputs={'./outputs/output.avi': ['-y']},
# outputs={'./outputs/output.mp4': None}
# )
# ff.run()
return
channels = [0, 1]
ranges = [0, 180, 0, 256]
hist = cv2.calcHist([roi_hsv], channels, None, [90, 128], ranges)
# Mean Shift 알고리즘 종료 기준
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
# 비디오 매 프레임 처리
while True:
ret, frame = cap.read()
if not ret:
break
# HS 히스토그램에 대한 역투영
frame_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
backproj = cv2.calcBackProject([frame_hsv], channels, hist, ranges, 1)
# Mean Shift
_, rc = cv2.meanShift(backproj, rc, term_crit)
# 추적 결과 화면 출력
cv2.rectangle(frame, rc, (0, 0, 255), 2)
cv2.imshow('frame', frame)
if cv2.waitKey(60) == 27:
break
cap.release()
cv2.destroyAllWindows()
def detect_video(self, yolo, video_path):
from PIL import Image, ImageFont, ImageDraw
#Start ROS node
# pub, pub_flag, pub_track, pub_frame1, pub_frame2 = start_node()
pub, pub_flag, pub_frame1, pub_frame2 = start_node()
vid = RealsenseCapture()
vid.start()
bridge = CvBridge()
accum_time = 0
curr_fps = 0
fps = "FPS: ??"
prev_time = timer()
worldy = 0.0
flag = 0
while True:
# pub_track.publish(0)
# flag = 0
if self.garbage_in_can == 1:
# print("ゴミを捨てました")
flag = 0
pub_flag.publish(flag)
ret, frames, _ = vid.read()
frame = frames[0]
depth_frame = frames[1]
image = Image.fromarray(frame)
image, bottle, person, right, left, bottom, top, right2, left2, bottom2, top2 = yolo.detect_image(
image, pub)
result = np.asarray(image)
curr_time = timer()
exec_time = curr_time - prev_time
prev_time = curr_time
accum_time = accum_time + exec_time
curr_fps = curr_fps + 1
if accum_time > 1:
accum_time = accum_time - 1
fps = "FPS: " + str(curr_fps)
curr_fps = 0
cv2.putText(result,
text=fps,
org=(3, 15),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.50,
color=(255, 0, 0),
thickness=2)
# cv2.imshow("result", result)
yolo_frame = bridge.cv2_to_imgmsg(result, "bgr8")
pub_frame1.publish(yolo_frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if (bottle == False) or (person == False):
continue
# ------------------------------Tracking-----------------------------------
# tracker_types = ['BOOSTING', 'MIL','KCF', 'TLD', 'MEDIANFLOW', 'GOTURN', 'MOSSE', 'CSRT']
# tracker_type = tracker_types[7]
tracker = cv2.TrackerCSRT_create()
tracker2 = cv2.TrackerCSRT_create()
# setup initial location of window
left, right, top, bottom = left, right, top, bottom
r, h, ci, w = top, bottom - top, left, right - left # simply hardcoded the values r, h, c, w
frame_b, frame_g, frame_r = frame[:, :, 0], frame[:, :,
1], frame[:, :,
2]
hist_b = cv2.calcHist([frame_b[top:bottom, left:right]], [0], None,
[256], [0, 256])
hist_g = cv2.calcHist([frame_g[top:bottom, left:right]], [0], None,
[256], [0, 256])
hist_r = cv2.calcHist([frame_r[top:bottom, left:right]], [0], None,
[256], [0, 256])
cv2.normalize(hist_b, hist_b, 0, 255, cv2.NORM_MINMAX)
cv2.normalize(hist_g, hist_g, 0, 255, cv2.NORM_MINMAX)
cv2.normalize(hist_r, hist_r, 0, 255, cv2.NORM_MINMAX)
track_window = (ci, r, w, h)
r2, h2, ci2, w2 = top2, bottom2 - top2, left2, right2 - left2 # simply hardcoded the values r, h, c, w
hist_bp = cv2.calcHist([frame_b[top2:bottom2, left2:right2]], [0],
None, [256], [0, 256])
hist_gp = cv2.calcHist([frame_g[top2:bottom2, left2:right2]], [0],
None, [256], [0, 256])
hist_rp = cv2.calcHist([frame_r[top2:bottom2, left2:right2]], [0],
None, [256], [0, 256])
cv2.normalize(hist_bp, hist_bp, 0, 255, cv2.NORM_MINMAX)
cv2.normalize(hist_gp, hist_gp, 0, 255, cv2.NORM_MINMAX)
cv2.normalize(hist_rp, hist_rp, 0, 255, cv2.NORM_MINMAX)
track_window2 = (ci2, r2, w2, h2)
cv2.imwrite('bottledetect.jpg', frame[r:r + h, ci:ci + w])
cv2.imwrite('persondetect.jpg', frame[r2:r2 + h2, ci2:ci2 + w2])
# set up the ROI for tracking
roi = frame[r:r + h, ci:ci + w]
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)),
np.array((180., 255., 255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10,
1)
ok = tracker.init(frame, track_window)
ok2 = tracker2.init(frame, track_window2)
track_thing = 0 #bottle
pts = Point()
pts2 = Point()
untrack = 0
self.emergency_stop = 0
# flag = 0
# pub_flag.publish(flag)
while (1):
ret, frames, depth = vid.read()
frame = frames[0]
depth_frame = frames[1]
if ret == True:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180],
1)
# apply meanshift to get the new location
ok, track_window = tracker.update(frame)
x, y, w, h = track_window
ok, track_window2 = tracker2.update(frame)
x2, y2, w2, h2 = track_window2
# Draw it on image
img2 = cv2.rectangle(frame, (x, y), (x + w, y + h), 255, 2)
if not track_thing:
img2 = cv2.rectangle(img2, (x2, y2),
(x2 + w2, y2 + h2), 255, 2)
else:
img2 = cv2.rectangle(img2, (x2, y2),
(x2 + w2, y2 + h2), (0, 0, 255),
2)
# cv2.imshow('Tracking',img2)
tracking_frame = bridge.cv2_to_imgmsg(img2, "bgr8")
pub_frame2.publish(tracking_frame)
# https://www.intelrealsense.com/wp-content/uploads/2020/06/Intel-RealSense-D400-Series-Datasheet-June-2020.pdf
total, cnt = 0, 0
for i in range(3):
for j in range(3):
dep = depth.get_distance(
np.maximum(0, np.minimum(i + x + w // 2, 639)),
np.maximum(0, np.minimum(j + y + h // 2, 479)))
if (dep) != 0:
total += dep
cnt += 1
if cnt != 0:
worldz = total / cnt
# 人にぶつからないように距離を確保するため
if (worldz < 0.6) or (worldz > 3.0):
worldz = 0
else:
worldz = 0
total2, cnt2 = 0, 0
for i in range(3):
for j in range(3):
dep2 = depth.get_distance(
np.maximum(0,
np.minimum(i + x2 + w2 // 2, 639)),
np.maximum(0,
np.minimum(j + y2 + h2 // 2, 479)))
if dep2 != 0:
total2 += dep2
cnt2 += 1
if cnt2 != 0:
worldz2 = total2 / cnt2
if (worldz2 < 0.6) or (worldz2 > 3.0):
worldz2 = 0
else:
worldz2 = 0
# print('worldz', worldz)
# print('worldz2', worldz2)
# if (worldz == 0) or (worldz2 == 0):
if worldz2 == 0:
# break
worldx, worldy = 0, 0
# worldx = 0
pts.x, pts.y, pts.z = 0.0, 0.0, 0.0
worldx2, worldy2 = 0, 0
pts2.x, pts2.y, pts2.z = 0.0, 0.0, 0.0
else:
# focus length = 1.93mm, distance between depth cameras = about 5cm, a pixel size = 3um
if (track_thing == 0) and (not worldz == 0):
#bottle Tracking
u_ud = (0.05 * 1.88 * 10**(-3)) / (3 * 10**(-6) *
worldz)
# print('u_ud', u_ud)
# print('x, y =', (x+w//2)-(img2.shape[1]//2), (img2.shape[0]//2)-(y+h//2))
# 深度カメラとカラーカメラの物理的な距離を考慮した項(-0.3*u_ud)
# これらの座標は物体を見たときの左の深度カメラを基準とする
worldx = 0.05 * (x + w // 2 -
(img2.shape[1] // 2) -
0.3 * u_ud) / u_ud
worldy = 0.05 * ((img2.shape[0] // 2) -
(y + h)) / u_ud
print('x,y,z = ', worldx, worldy, worldz - 0.6)
pts.y, pts.z, pts.x = -1.0 * float(worldx), float(
worldy), float(worldz) - 0.6
# pts.y, pts.z, pts.x = float(0.0), float(worldy), float(1.0)
else:
#human Tracking
# if worldz==0:
# worldx, worldy = 0, 0
# pts.x, pts.y, pts.z = 0.0, 0.0, 0.0
u_ud = (0.05 * 1.88 * 10**(-3)) / (3 * 10**(-6) *
worldz2)
worldx2 = 0.05 * (x2 + w2 // 2 -
(img2.shape[1] // 2) -
0.3 * u_ud) / u_ud
worldy2 = 0.05 * ((img2.shape[0] // 2) -
(y2 + h2)) / u_ud
print('x2,y2,z2 = ', worldx2, worldy2,
worldz2 - 0.6)
pts2.y, pts2.z, pts2.x = -1.0 * float(
worldx2), float(worldy2), float(worldz2) - 0.6
# pts.y, pts.z, pts.x = float(0.0), float(worldy), float(1.0)
if worldz == 0:
worldx, worldy = 0, 0
pts.x, pts.y, pts.z = 0.0, 0.0, 0.0
print("track_thing = ", track_thing)
frame_b, frame_g, frame_r = frame[:, :,
0], frame[:, :,
1], frame[:, :,
2]
hist_b2 = cv2.calcHist([frame_b[y:y + h, x:x + w]], [0],
None, [256], [0, 256])
hist_g2 = cv2.calcHist([frame_g[y:y + h, x:x + w]], [0],
None, [256], [0, 256])
hist_r2 = cv2.calcHist([frame_r[y:y + h, x:x + w]], [0],
None, [256], [0, 256])
cv2.normalize(hist_b2, hist_b2, 0, 255, cv2.NORM_MINMAX)
cv2.normalize(hist_g2, hist_g2, 0, 255, cv2.NORM_MINMAX)
cv2.normalize(hist_r2, hist_r2, 0, 255, cv2.NORM_MINMAX)
hist_bp2 = cv2.calcHist([frame_b[y2:y2 + h2, x2:x2 + w2]],
[0], None, [256], [0, 256])
hist_gp2 = cv2.calcHist([frame_g[y2:y2 + h2, x2:x2 + w2]],
[0], None, [256], [0, 256])
hist_rp2 = cv2.calcHist([frame_r[y2:y2 + h2, x2:x2 + w2]],
[0], None, [256], [0, 256])
cv2.normalize(hist_bp2, hist_bp2, 0, 255, cv2.NORM_MINMAX)
cv2.normalize(hist_gp2, hist_gp2, 0, 255, cv2.NORM_MINMAX)
cv2.normalize(hist_rp2, hist_rp2, 0, 255, cv2.NORM_MINMAX)
comp_b = cv2.compareHist(hist_b, hist_b2,
cv2.HISTCMP_CORREL)
comp_g = cv2.compareHist(hist_g, hist_g2,
cv2.HISTCMP_CORREL)
comp_r = cv2.compareHist(hist_r, hist_r2,
cv2.HISTCMP_CORREL)
comp_bp = cv2.compareHist(hist_bp, hist_bp2,
cv2.HISTCMP_CORREL)
comp_gp = cv2.compareHist(hist_gp, hist_gp2,
cv2.HISTCMP_CORREL)
comp_rp = cv2.compareHist(hist_rp, hist_rp2,
cv2.HISTCMP_CORREL)
# print('compareHist(b)', comp_b)
# print('compareHist(g)', comp_g)
# print('compareHist(r)', comp_r)
# print('compareHist(bp)', comp_bp)
# print('compareHist(gp)', comp_gp)
# print('compareHist(rp)', comp_rp)
# print("garbage_in_can", garbage_in_can)
# 追跡を止める条件は，bottle追跡中にヒストグラムが大きく変化するか枠が無くなるまたはpersonを見失う，もしくはperson追跡中にヒストグラムが大きく変化するか枠が無くなるまたはゴミがゴミ箱に入れられた，
if ((track_thing == 0 and
((comp_b <= 0.1) or (comp_g <= 0.1) or
(comp_r <= 0.1) or track_window == (0, 0, 0, 0)))
or (track_window2 == (0, 0, 0, 0))
or (track_thing == 1 and
((comp_bp <= 0.) or (comp_gp <= 0.) or
(comp_rp <= 0.)))):
untrack += 1
print("untrack = ", untrack)
if untrack >= 30:
print("追跡が外れた！\n")
break
elif (track_thing == 0 and (x + w > 640 or x < 0) and
(y + h > 480
or y < 0)) or (track_thing == 1 and
(x2 + w2 > 640 or x2 < 0) and
(y2 + h2 > 480 or y2 < 0)):
untrack += 1
print("untrack = ", untrack)
if untrack >= 50:
print("枠が画面外で固まった")
break
# elif (track_thing==1 and self.garbage_in_can==1):
elif self.garbage_in_can == 1:
print("ゴミを捨てたため追跡を終えます")
flag = 0
break
else:
untrack = 0
# print('garbage_in_can', self.garbage_in_can)
# ポイ捨ての基準はbottleを追跡していて，地面から10cmのところまで落ちたか，bottleを見失ったかつ見失う前のフレームでの高さがカメラの10cmより下
# print('track_window = ', track_window)
if (((worldy <= -0.01) or
((track_window == (0, 0, 0, 0) or untrack >= 1) and
(worldy < 0.5))) and (not track_thing)):
print("ポイ捨てした！\n")
track_thing = 1 #human
# if track_thing==0:
# tracking_point = pts
# if not (pts.x==0.0 and pts.y==0.0 and pts.z==0.0):
# pub.publish(tracking_point)
# flag = 0 #bottle
# else:
# tracking_point = pts2
# if not (pts2.x==0.0 and pts2.y==0.0 and pts2.z==0.0):
# pub.publish(tracking_point)
# flag = 1 #person
if track_thing == 1:
tracking_point = pts2
if not (pts2.x == 0.0 and pts2.y == 0.0
and pts2.z == 0.0):
pub.publish(tracking_point)
flag = 1
# else:
# flag = 0
pub_flag.publish(flag)
k = cv2.waitKey(1) & 0xff
# print("emergency_stop", self.emergency_stop)
# if (k == 27) or self.emergency_stop==1: # dev
if self.emergency_stop == 1: # ops
print('emergency_stop == 1')
break
else:
break
# pub_track.publish(1)
# pub_flag.publish(flag)
yolo.close_session()
def store_images(g_id):
total_pics = 1200
if g_id == str(0):
create_empty_images("0", total_pics)
return
hist = get_hand_hist()
cam = cv2.VideoCapture(1)
x, y, w, h = 300, 100, 300, 300
create_folder("gestures/" + str(g_id))
pic_no = 0
flag_start_capturing = False
frames = 0
while True:
img = cam.read()[1]
img = cv2.flip(img, 1)
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]
contours = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[1]
if len(contours) > 0:
contour = max(contours, key=cv2.contourArea)
if cv2.contourArea(contour) > 10000 and frames > 50:
x1, y1, w1, h1 = cv2.boundingRect(contour)
pic_no += 1
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))
save_img = cv2.resize(save_img, (image_x, image_y))
cv2.putText(img, "Capturing...", (30, 60),
cv2.FONT_HERSHEY_TRIPLEX, 2, (127, 255, 255))
cv2.imwrite(
"gestures/" + str(g_id) + "/" + str(pic_no) + ".jpg",
save_img)
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.putText(img, str(pic_no), (30, 400), cv2.FONT_HERSHEY_TRIPLEX, 1.5,
(127, 127, 255))
cv2.imshow("Capturing gesture", img)
cv2.imshow("thresh", thresh)
keypress = cv2.waitKey(1)
if keypress == ord('c'):
if flag_start_capturing == False:
flag_start_capturing = True
else:
flag_start_capturing = False
frames = 0
if flag_start_capturing == True:
frames += 1
if pic_no == total_pics:
break
hist = cv.calcHist([hsv_roi], [0], mask_roi, [16], [0, 180])
# Normilize from 0 to 256
cv.normalize(hist, hist, 0, 255, cv.NORM_MINMAX)
# Transpose of histogram matrix
hist = hist.reshape(-1)
# Calling function to display the histogram
show_hist(hist)
# Initializing the area of tracking
# Calculating from diag points, width and height
track_window = (x0, y0, x1 - x0, y1 - y0)
# Calculating the back proj of a hist (images, chanels, hist, ranges, scale[,dist})
# obtain probability of each pixel of that region belonging to a face or not (depending on color)
prob = cv.calcBackProject([hsv], [0], hist, [0, 180], 1)
#prob = prob & mask
prob &= mask
term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1) #termination criteria for camshift
# Running camshift (first time)
track_box, track_window = cv.CamShift(prob, track_window, term_crit)
# Getting the coordinates of the face region and a little enalrging the box
((x3, y3), (w, z), k) = track_box
x0 = int(x3 - w / 2)
x1 = int(x3 + w / 2)
y0 = int(y3 - z / 2)
y1 = int(y3 + z / 2)
def aslrun(frame2):
letter_lookup = {
0: 'A',
1: 'B',
2: 'C',
3: 'D',
4: 'E',
5: 'F',
6: 'G',
7: 'H',
8: 'I',
9: 'J',
10: 'K',
11: 'L',
12: 'M',
13: 'N',
14: 'O',
15: 'P',
16: 'Q',
17: 'R',
18: 'S',
19: 'T',
20: 'U',
21: 'V',
22: 'W',
23: 'X',
24: 'Y',
25: 'Z',
26: ' ',
27: '&',
28: '#'
}
number_lookup = {
0: '1',
1: '2',
2: '3',
3: '4',
4: '5',
5: '6',
6: '7',
7: '8',
8: '9',
9: '0',
10: '#'
}
cont = frame2
hist = hand_hist()
imghsv = cv2.cvtColor(frame2, 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, (5, 5), 0)
blur = cv2.medianBlur(blur, 7)
kernel1 = np.ones((5, 5), np.uint8)
blur = cv2.morphologyEx(blur, cv2.MORPH_DILATE, kernel1)
cv2.imshow("Output", dst)
cv2.imshow("Output1", blur)
_, contours, hierarchy = cv2.findContours(blur.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
back_img = np.ones((cont.shape[0], cont.shape[1]), dtype="uint8")
back_img = back_img * 255
if len(contours) == 0:
print("Not Detected")
pred_list = []
else:
hand_segment = max(contours, key=cv2.contourArea)
cv2.drawContours(back_img, [hand_segment], -1, (0, 0, 0), -1)
cont = cv2.cvtColor(cont, cv2.COLOR_BGR2GRAY)
cv2.bitwise_or(cont, back_img, dst=back_img)
cv2.imshow("bi", back_img)
### Code when lighting is great
frame2 = back_img
kernel2 = np.ones(shape=(3, 3), dtype=np.float32) / 4
frame2 = cv2.filter2D(frame2, -1, kernel2)
cv2.imshow('filter', frame2)
# frame2=cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
kernel3 = np.ones((3, 3), np.uint8)
gradient = cv2.morphologyEx(frame2, cv2.MORPH_GRADIENT, kernel3)
cv2.imshow('image1', gradient)
# predict character using the classifier model
gradient2 = cv2.resize(gradient, (128, 128))
gradient2 = gradient2.reshape(1, 128, 128, 1)
if mode == 0:
out = classifier1.predict_classes(gradient2)
pred_var = letter_lookup[int(out)]
elif mode == 1:
out = classifier2.predict_classes(gradient2)
pred_var = number_lookup[int(out)]
return pred_var
# Process Detected People
if len(detectedPeople) != 0:
for people in detectedPeople:
# Setup Meanshift/Camshift for Tracking
track_window = (people.x, people.y, people.w, people.h)
hsv_roi = pOpening[int(people.y):int(people.y + people.h),
int(people.x):int(people.x + people.w)]
mask = cv2.inRange(hsv_roi, np.array(128), np.array(256))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [100], [0, 256])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
term_criteria = (
cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 1, 1
) # Setup the termination criteria, either 10 iteration or move by atleast 1 pt
dst = cv2.calcBackProject([opening], [0], roi_hist, [0, 256], 1)
ret, track_window = cv2.CamShift(dst, track_window, term_criteria)
# Process POST Tracking
pts = cv2.boxPoints(ret)
pts = np.int0(pts)
img2 = cv2.polylines(frameForView, [pts], True, people.color, 2)
pos = sum(pts) / len(pts)
isFound = False
for dC in detectedContours:
if dC.x - toleranceRange < pos[0] < dC.x + dC.w + toleranceRange \
and dC.y - toleranceRange < pos[1] < dC.y + dC.h + toleranceRange:
people.set("x", dC.x)
people.set("y", dC.y)
people.set("w", dC.w)
people.set("h", dC.h)
def start_tracking(self):
#Iterate until the user presses the esc key
while True:
#Capture the frame from the webcam
_, self.frame = self.cap.read()
#resize the input frame
self.frame = cv2.resize(self.frame,
None,
fx=self.scaling_factor,
fy=self.scaling_factor,
interpolation=cv2.INTER_AREA)
#create a copy of the frame
vis = self.frame.copy()
#convert the frame to HSV colorspace
hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV)
#create the mask based on predefined
mask = cv2.inRange(hsv, np.array(0., 60., 32.)), np.array(
(180., 255., 255.))
#check if the user has select the region
if self.selection:
x0, y0, x1, y1 = self.selection
self.track_window = (x0, y0, x1 - x0, y1 - y0)
hsv_roi = hsv[y0:y1, x0:x1]
mask_roi = mask[y0:y1, x0:x1]
hist = cv2.calcHist([hsv_roi], [0], mask_roi, [16],
[0, 180])
cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)
self.hist = hist.reshape(-1)
vis_roi = vis[y0:y1, x0:x1]
cv2.bitwise_not(vis_roi, vis_roi)
vis[mask == 0] = 0
if self.tracking_state == 1:
self.selection = None
hsv_backproj = cv2.calcBackProject([hsv], [0], self.hist,
[0, 180], 1)
hsv_backproj &= mask
term_crit = (cv2.TERM_CRITERIA_EPS
| cv2.TERM_CRITERIA_COUNT, 10, 1)
track_box, self.track_window = cv2.CamShift(
hsv_backproj, self.track_window, term_crit)
cv2.ellipse(vis, track_box, (0, 255, 0), 2)
cv2.imshow('Object Tracker', vis)
c = cv2.waitKey(5)
if c == 27:
break
def prediction():
def get_hand_hist():
with open("hist", "rb") as f:
hist = pickle.load(f)
return hist
image_x, image_y = (50, 50)
def keras_process_image(img): # test할 이미지를 배열 값으로 반환
img = cv2.resize(img, (image_x, image_y))
img = np.array(img, dtype=np.float32)
img = np.reshape(img, (1, image_x, image_y, 1))
return img
def keras_predict(model, image): # 배열값을 가지고 이미지 예측
processed = keras_process_image(image)
with graph.as_default():
pred_probab = model.predict(processed)[0]
pred_class = list(pred_probab).index(max(pred_probab))
return max(pred_probab), pred_class
def get_pred_text_from_db(pred_class): # 데이터 베이스에서 이름 찾기
conn = sqlite3.connect("gesture_db.db")
cmd = "SELECT g_name FROM gesture WHERE g_id=" + str(pred_class)
cursor = conn.execute(cmd)
for row in cursor:
return row[0]
def get_pred_from_contour(contour, thresh): # 이미지 판정
x1, y1, w1, h1 = cv2.boundingRect(contour)
save_img = thresh[y1:y1 + h1, x1:x1 + w1]
name = ""
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 > 70:
name = get_pred_text_from_db(pred_class)
return name
keras_predict(model, np.zeros((50, 50), dtype=np.uint8))
hist = get_hand_hist() # 저장된 손의 히스토그램
x, y, w, h = 300, 100, 300, 300
global cam
cam = cv2.VideoCapture(1)
if cam.read()[0] == False:
cam = cv2.VideoCapture(0)
name = ""
line = ""
path_name = "static/output.txt"
T = open(path_name, 'wt', encoding='utf-8')
T.write("")
T.close()
end = 0
while True:
img = cam.read()[1] # 이미지 컨투어링 시키는 함수
img = cv2.resize(img, (640, 480))
img = cv2.flip(img, 1)
imgHSV = cv2.cvtColor(
img, cv2.COLOR_BGR2HSV) # bgr색공간의 이미지를 hsv 색공간 이미지로 변환
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]
# 이미지 문턱값 지정해주고 이미지 픽셀값이 문턱값보다 크면 255 값을 갖고 문턱보다 작으면 0을 갖도록(픽셀분류)
thresh = cv2.merge(
(thresh, thresh, thresh)) # 1채널의 바이너리 이미지를 3채널 이미지로 변환
thresh = cv2.cvtColor(thresh, cv2.COLOR_BGR2GRAY) # 흑백으로 색변환
thresh = thresh[y:y + h, x:x + w]
contours = cv2.findContours(thresh.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[1] # 만들어진 윤곽선 값
if len(contours) > 0: # 컨투어링 값이 생기면
end = 0
contour = max(contours, key=cv2.contourArea) # 최대값 뽑아서
keypress = cv2.waitKey(1)
if cv2.contourArea(contour) > 10000 and keypress == ord(
'c'): # C 눌렀을때
name = get_pred_from_contour(
contour, thresh) # 데이터베이스에서 컨투어링, 임계값에 일치하는 이름 들고옴
print("name : " + name)
R = open(path_name, 'rt', encoding='utf-8')
line = ""
while True:
line = line + R.readline()
if not R.readline(): break
R.close()
T = open(path_name, 'wt', encoding='utf-8')
name = line + name
T.write(name)
T.close()
sentence = join_jamos(name)
print(sentence)
elif cv2.contourArea(contour) < 1000 and keypress == ord('c'):
name = " "
#print("not found")
elif keypress == ord('f'):
end = 1
elif keypress == ord('e'):
R = open(path_name, 'rt', encoding='utf-8')
line = ""
while True:
line = line + R.readline()
if not R.readline(): break
R.close()
newline = ""
for i in range(0, len(line) - 1):
newline = newline + line[i]
T = open(path_name, 'wt', encoding='utf-8')
T.write(newline)
line = newline
print("", line)
T.close()
R = open(path_name, 'r', encoding='utf-8')
new_line = ""
while True:
new_line = new_line + R.readline()
if not R.readline(): break
T = open(path_name, 'wt', encoding='utf-8')
sentence = join_jamos(new_line)
T.write(sentence)
cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
# cv2.putText(img, str(line), (30, 400), cv2.FONT_HERSHEY_DUPLEX, 1.5, (255, 255, 255))
cv2.imshow("Capturing gesture", img)
cv2.imshow("output", thresh)
if end == 1:
cam.release()
cv2.destroyAllWindows()
break
def run(self):
while True:
_ret, self.frame = self.cam.read()
vis = self.frame.copy()
hsv = cv.cvtColor(
src=self.frame, code=cv.COLOR_BGR2HSV
) # convert to HSV to reduce the influence of lightness
mask = cv.inRange(src=hsv,
lowerb=np.array((0., 60., 32.)),
upperb=np.array((180., 255., 255.)))
# if self.selection:
# x0, y0, x1, y1 = self.selection
# hsv_roi = hsv[y0:y1, x0:x1]
# mask_roi = mask[y0:y1, x0:x1]
# hist = cv.calcHist([hsv_roi], [0], mask_roi, [16], [0, 180] )
# cv.normalize(hist, hist, 0, 255, cv.NORM_MINMAX)
# self.hist = hist.reshape(-1)
# self.show_hist()
#
# vis_roi = vis[y0:y1, x0:x1]
# cv.bitwise_not(vis_roi, vis_roi)
# vis[mask == 0] = 0
if self.selections:
for idx, selection in enumerate(self.selections):
if selection:
x0, y0, x1, y1 = selection
hsv_roi = hsv[y0:y1, x0:x1]
mask_roi = mask[y0:y1, x0:x1]
hist = cv.calcHist(images=[hsv_roi],
channels=[0],
mask=mask_roi,
histSize=[16],
ranges=[0, 180])
cv.normalize(src=hist,
dst=hist,
alpha=0,
beta=255,
norm_type=cv.NORM_MINMAX)
# self.hist = hist.reshape(-1)
try:
self.hist_list[idx] = hist.reshape(
-1) # update hist
except:
self.hist_list.append(
hist.reshape(-1)) # add hist if select new
self.show_hist(idx)
vis_roi = vis[y0:y1, x0:x1]
cv.bitwise_not(vis_roi, vis_roi)
vis[mask == 0] = 0
self.show_hist(idx)
# if self.track_window and self.track_window[2] > 0 and self.track_window[3] > 0:
# self.selection = None
# prob = cv.calcBackProject([hsv], [0], self.hist, [0, 180], 1)
# prob &= mask
# term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1)
# track_box, self.track_window = cv.CamShift(prob, self.track_window, term_crit)
#
# if self.show_backproj:
# vis[:] = prob[...,np.newaxis]
# try:
# cv.ellipse(vis, track_box, (0, 0, 255), 2)
# except:
# print(track_box)
if self.track_windows:
for idx, track_window in enumerate(self.track_windows):
if track_window and track_window[2] > 0 and track_window[
3] > 0:
self.selections[
idx] = None # FIXME: comment this line for refresh hist, however, that will lead to bad display
prob = cv.calcBackProject(images=[hsv],
channels=[0],
hist=self.hist_list[idx],
ranges=[0, 180],
scale=1)
prob &= mask
term_crit = (cv.TERM_CRITERIA_EPS
| cv.TERM_CRITERIA_COUNT, 10, 1)
track_box, self.track_windows[idx] = cv.CamShift(
probImage=prob,
window=track_window,
criteria=term_crit)
if self.show_backproj:
vis[:] = prob[..., np.newaxis]
try:
cv.ellipse(vis, track_box,
self.track_box_colors[idx], 2)
except:
print(track_box)
cv.imshow('camshift', vis)
ch = cv.waitKey(5)
if ch == 27:
break
if ch == ord('b'):
self.show_backproj = not self.show_backproj
cv.destroyAllWindows()
cols=frame.shape[1] cv2.rectangle(frame, (int(rows/3),int(cols/2.5)), (int(rows/3+SQ_SIZE),int(cols/2.5)+SQ_SIZE), (0,255,255)) cv2.rectangle(frame, (int(rows/4.2),int(cols/2.9)), (int(rows/4.2+SQ_SIZE),int(cols/2.9)+SQ_SIZE), (0,255,255)) cv2.rectangle(frame, (int(rows/2.7),int(cols/3.6)), (int(rows/2.7+SQ_SIZE),int(cols/3.6)+SQ_SIZE), (0,255,255)) cv2.rectangle(frame, (int(rows/4),int(cols/2.3)), (int(rows/4+SQ_SIZE),int(cols/2.3)+SQ_SIZE), (0,255,255)) cv2.rectangle(frame, (int(rows/2),int(cols/2.5)), (int(rows/2+SQ_SIZE),int(cols/2.5)+SQ_SIZE), (0,255,255)) cv2.rectangle(frame, (int(rows/2.7),int(cols/8)), (int(rows/2.7+SQ_SIZE),int(cols/8)+SQ_SIZE), (0,255,255)) roi_1=orig[int(cols/2.5):int(cols/2.5)+SQ_SIZE, int(rows/3):int(rows/3+SQ_SIZE)] rh1 = cv2.calcHist([roi_1],[0, 1], None, [256, 256], [0, 256, 0, 256] ) if(reset): mean_1=cv2.mean(roi_1) # TR_MIN = np.array([0, max(mean_1[1]-sat_sens,0), mean_1[2]-val_sens],np.uint8) # TR_MAX = np.array([mean_1[0]+hue_sens, mean_1[1]+sat_sens, mean_1[2]+val_sens],np.uint8) # tr_1=cv2.inRange(orig, TR_MIN, TR_MAX) tr_1=cv2.calcBackProject([frame],[0,1],rh1,[0,256,0,256],1) roi_2=orig[int(cols/2.9):int(cols/2.9)+SQ_SIZE, int(rows/4.2):int(rows/4.2+SQ_SIZE)] rh2 = cv2.calcHist([roi_2],[0, 1], None, [256, 256], [0, 256, 0, 256] ) if(reset): mean_2=cv2.mean(roi_2) # TR_MIN = np.array([0, max(mean_2[1]-sat_sens,0), mean_2[2]-val_sens],np.uint8) # TR_MAX = np.array([mean_2[0]+hue_sens, mean_2[1]+sat_sens, mean_2[2]+val_sens],np.uint8) # tr_2=cv2.inRange(orig, TR_MIN, TR_MAX) tr_2=cv2.calcBackProject([frame],[0,1],rh2,[0,256,0,256],1) roi_3=orig[int(cols/3.6):int(cols/3.6)+SQ_SIZE, int(rows/2.7):int(rows/2.7+SQ_SIZE)] rh3 = cv2.calcHist([roi_3],[0, 1], None, [256, 256], [0, 256, 0, 256] ) if(reset):
def get_hand_hist():
def build_squares(img):
x, y, w, h = 420, 140, 10, 10
d = 10
imgCrop = None
crop = None
for i in range(10):
for j in range(5):
if np.any(imgCrop == None):
imgCrop = img[y:y + h, x:x + w]
else:
imgCrop = np.hstack((imgCrop, img[y:y + h, x:x + w]))
# print(imgCrop.shape)
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 1)
x += w + d
if np.any(crop == None):
crop = imgCrop
else:
crop = np.vstack((crop, imgCrop))
imgCrop = None
x = 420
y += h + d
return crop
cam = cv2.VideoCapture(1)
if cam.read()[0] == False:
cam = cv2.VideoCapture(0)
x, y, w, h = 300, 100, 300, 300
flagPressedC, flagPressedS = False, False
imgCrop = None
while True:
img = cam.read()[1]
img = cv2.flip(img, 1)
img = cv2.resize(img, (640, 480))
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
keypress = cv2.waitKey(1)
if keypress == ord('c'):
hsvCrop = cv2.cvtColor(imgCrop, cv2.COLOR_BGR2HSV)
flagPressedC = True
hist = cv2.calcHist([hsvCrop], [0, 1], None, [180, 256],
[0, 180, 0, 256])
cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX)
elif keypress == ord('s'):
flagPressedS = True
break
if flagPressedC:
dst = cv2.calcBackProject([hsv], [0, 1], hist, [0, 180, 0, 256], 1)
dst1 = dst.copy()
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)
ret, thresh = cv2.threshold(blur, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
thresh = cv2.merge((thresh, thresh, thresh))
# cv2.imshow("res", res)
cv2.imshow("output", thresh)
if not flagPressedS:
imgCrop = build_squares(img)
# cv2.rectangle(img, (x,y), (x+w, y+h), (0,255,0), 2)
cv2.imshow("Set hand color", img)
cam.release()
cv2.destroyAllWindows()
with open("hist", "wb") as f:
pickle.dump(hist, f)
return render_template("main.html")
def run_main():
#To save the video later
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output1.avi ', fourcc, 20.0, (640, 480))
cap = cv2.VideoCapture('video/thermal_stereo_mv.mp4')
#cap = cv2.VideoCapture('video/WhatsApp.mp4')
# Read the first frame of the video
ret, frame = cap.read()
height, width, channels = frame.shape
print(height, width, channels)
frame = frame[0:480, 0:1280] #left
#frame = frame[0:480,640:1280] # right
#feature detection
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
corners = cv2.goodFeaturesToTrack(gray, 25, 0.01, 10)
corners = np.int0(corners)
# Set the ROI (Region of Interest). Actually, this is a
# rectangle of the building that we're tracking
x, y = corners[22].ravel()
c, r, w, h = x, y, 50, 50
track_window = (c, r, w, h)
# Create mask and normalized histogram
roi = frame[r:r + h, c:c + w]
#hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
hsv_roi = roi
lower_grey = np.array([0, 255, 255])
upper_grey = np.array([10, 255, 255])
#mask = cv2.inRange(hsv_roi, np.array((0., 30., 32.)), np.array((180., 255., 255.)))
mask = cv2.inRange(hsv_roi, lower_grey, upper_grey)
#roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
roi_hist = cv2.calcHist([hsv_roi], [0], None, [256], [0, 256])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 80, 1)
#grey = np.uint8([[[0, 0, 255]]])
#hsv_grey = cv2.cvtColor(grey, cv2.COLOR_BGR2HSV)
#print (hsv_grey)
while True:
ret, frame = cap.read()
#hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)
dst = cv2.calcBackProject([frame], [0], roi_hist, [0, 256], 1)
ret, track_window = cv2.meanShift(dst, track_window, term_crit)
x, y, w, h = track_window
cv2.rectangle(frame, (x, y), (x + w, y + h), 255, 2)
cv2.putText(frame, 'Tracked', (x - 25, y - 10),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2,
cv2.CV_8UC1) #CV_AA)
out.write(frame)
cv2.imshow('Tracking', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
out.release()
cv2.destroyAllWindows()
import numpy as np
cap = cv.VideoCapture()
ret, frame = cap.read()
face_cascade = cv.CascadeClassifier('')
face_rects = face_cascade.detectMultiScale(frame)
x, y, w, h = tuple(face_rects[0])
track_window = (x, y, w, h)
roi = frame[x:y + h, x:x + w]
hsv_roi = cv.cvtColor(roi, cv.COLOR_BGR2HSV)
roi_hist = cv.calcHist([hsv_roi, [0], None, [180], [0, 180]])
cv.normalize(roi_hist, roi_hist, 0, 255, cv.NORM_MINIMAX)
term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1)
while True:
ret, frame = cap.read()
if ret == True:
hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
dest_roi = cv.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)
ret, track_window = cv.meanShift(dest_roi, track_window, term_crit)
x, y, w, h = track_window
img2 = cv.rectangle(frame, (x, y), (x + w, y + h), (255, 255, 0), 3)
cv.imshow('FaceTracker', img2)
if cv.waitKey(50) & 0xFF == ord('q'):
break
cap.release()
cv.destroyAllWindows()
roi = frame[r:r + h, c:c + w]
hsv_roi = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 60., 32.)),
np.array((180., 255., 255.)))
roi_hist = cv2.calcHist([hsv_roi], [0], mask, [180], [0, 180])
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX)
# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1)
while (1):
ret, frame = cap.read()
if ret == True:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1)
# apply meanshift to get the new location
ret, track_window = cv2.CamShift(dst, track_window, term_crit)
# Draw it on image
pts = cv2.boxPoints(ret)
pts = np.int0(pts)
img2 = cv2.polylines(frame, [pts], True, 255, 2)
cv2.imshow('img2', img2)
k = cv2.waitKey(60) & 0xff
if k == 27:
break
else:
cv2.imwrite(chr(k) + ".jpg", img2)
else:
def filterImageForHand(frame, histogram):
backProject = cv2.calcBackProject([frame], [0,1], histogram, [0, 180, 0, 256], scale=1)
cv2.imshow('BackProj', backProject)
top_left = (boxes[0][0], boxes[0][1])
bottom_right = (current_mouse_position[0],
current_mouse_position[1])
cv2.rectangle(frame, top_left, bottom_right, (0, 255, 0), 2)
# if we have a selected region
if (cropped):
# convert incoming image to HSV
img_hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# back projection of histogram based on Hue and Saturation only
img_bproject = cv2.calcBackProject([img_hsv], [0, 1], crop_hist,
[0, 180, 0, 255], 1)
cv2.imshow(window_name2, img_bproject)
# apply camshift to predict new location (observation)
# basic HSV histogram comparision with adaptive window size
# see :
# http://docs.opencv.org/3.1.0/db/df8/tutorial_py_meanshift.html
ret, track_window = cv2.CamShift(img_bproject, track_window,
term_crit)
# draw observation on image - in BLUE
x, y, w, h = track_window
frame = cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0),
2)
# extract centre of this observation as points
def _tracking(self, frame):
vis = frame.copy()
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv, np.array((0., 60., 32.)),
np.array((180., 255., 255.)))
cv2.polylines(vis, [np.array([[500, 1056], [600, 1200]], np.int32)],
False, (0, 255, 0))
if self.selection:
x0, y0, x1, y1 = self.selection
hsv_roi = hsv[y0:y1, x0:x1]
mask_roi = mask[y0:y1, x0:x1]
self.hist = cv2.calcHist([hsv_roi], [0], mask_roi, [16], [0, 180])
cv2.normalize(self.hist, self.hist, 0, 255, cv2.NORM_MINMAX)
self.hist = self.hist.reshape(-1)
vis_roi = vis[y0:y1, x0:x1]
cv2.bitwise_not(vis_roi, vis_roi)
# vis[mask == 0] = 0
if self.trackWindow and self.trackWindow[2] > 0 and self.trackWindow[
3] > 0:
self.selection = None
prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1)
prob &= mask
term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10,
1)
track_box, self.trackWindow = cv2.CamShift(prob, self.trackWindow,
term_crit)
if self.showBackproj:
vis[:] = prob[..., np.newaxis]
try:
cv2.ellipse(vis, track_box, (0, 0, 255), 2)
point_track = track_box[0]
if (point_track != (0, 0)) and isinstance(
point_track, tuple) and (point_track
not in self.trackPoints):
self.timestamps.append(
self.capture.get(0)) # get timestamp
self.trackPoints.append(point_track)
if self.isCalibrated:
point_move = (point_track[0] - self.trackPoints[0][0],
point_track[1] - self.trackPoints[0][1])
point_move = tuple(map(self._pixel2unit, point_move))
self.movePoints.append(point_move)
self.labelPos.setText(
"<font color='red'>({:.1f}ms: {:.4f}cm, {:.4f}cm)</font>"
.format(self.timestamps[-1], point_move[0],
point_move[1]))
cv2.circle(vis, (int(point_track[0]), int(point_track[1])), 2,
(0, 255, 0), -1)
cv2.polylines(vis, [
np.array([np.int32(list(tr)) for tr in self.trackPoints])
], False, (0, 255, 0))
# display tracking point
self.labelTrack.setText(
"<font color='red'>({:.1f}ms: {:.0f}, {:.0f})</font>".
format(self.timestamps[-1], point_track[0],
point_track[1]))
except Exception as e:
print("Exception while drawing")
print(e)
print(track_box)
# raise e
return vis
