def __init__(self,ratio=0.002,learningRate=-1):
self.bgSubtractor = cv2.createBackgroundSubtractorKNN()
#self.bgSubtractor = cv2.BackgroundSubtractorMOG2()
self.ratio = ratio
self.learningRate = learningRate
self.scale = 1
self.fgmask = np.array([])
#self.bgm = np.array([])
self.contourList = []
self.maxContour = []
self.bbox = []
self.contourRects = []
self.ret = False
def __init__(self, video_src):
self.cam = cv2.VideoCapture(video_src)
ret, self.frame = self.cam.read()
cv2.namedWindow('gesture_hci')
self.cmd_switch = False
self.mask_lower_yrb = np.array([54, 131, 110]) #[54, 131, 110]
self.mask_upper_yrb = np.array([143, 157, 155]) #[163, 157, 135]
self.fgbg = cv2.createBackgroundSubtractorKNN()
#self.fgbg = cv2.BackgroundSubtractorMOG2(history=120, varThreshold=50, bShadowDetection=True)
# create trackbar for skin calibration
self.calib_switch = False
def main():
# ####upper and lower bounds for colors
# yellow bounds from:
# https://stackoverflow.com/questions/9179189/detect-yellow-color-in-opencv
camera = cv2.VideoCapture(0)
lower_blue = np.array([110, 50, 50])
upper_blue = np.array([130, 255, 255])
lower_yellow = np.array([20, 100, 100])
upper_yellow = np.array([30, 255, 255])
grabBackground = 0;
fgbg = None;
reduction =None
background = None
grabbed = False
while True:
(ret, img_frame) = camera.read()
# set up img_frame for masking
img_frame = imutils.resize(img_frame, width=900)
img_frame = cv2.flip(img_frame, 1)
blah = img_frame.copy()
if (grabBackground <30):
grabBackground += 1
elif not grabbed:
fgbg = cv2.createBackgroundSubtractorKNN()
background = img_frame.copy()
grabbed = True
# create mask to block out all colors but blue
if fgbg != None:
img_frame = fgbg.apply(img_frame)
if background != None:
res = cv2.subtract(background,blah)
else: res = img_frame.copy()
res = cv2.erode(res, None, iterations=1)
res = cv2.dilate(res, None, iterations=1)
img_frame = cv2.erode(img_frame, None, iterations=2)
img_frame = cv2.dilate(img_frame, None, iterations=2)
cv2.imshow("other", res)
cv2.imshow("Frame", img_frame)
key = cv2.waitKey(1) & 0xFF
# if the 'q' key is pressed, stop the loop
if key == ord("q"):
break
# cleanup the camera and close any open windows
camera.release()
cv2.destroyAllWindows()
def maincv2(path):
k=9
vcap = cv2.VideoCapture('rtsp://*****:*****@172.16.56.108:554') #摄像头：'rtsp://*****:*****@172.17.13.250:554/h264/'+ch+'/main/av_stream'
fgbg = cv2.createBackgroundSubtractorKNN() #用非参数化方法背景建模
while True:
ret, frame = vcap.read()
frame = cv2.GaussianBlur(frame,(5,5),0)
#frame = imutils.resize(frame, width=int(800))
fgmask = fgbg.apply(frame) #获得前景（灰度图像）
if ret:
k+=1
print 'k',k
filename=path+'result/'+'image'+str(k)+'.png'
#nametv = path+'imagetv'+str(k)+'.png'
#namedelta = path+'imagedelta'+str(k)+'.png'
#cv2.imwrite(nametv, fgmask)
if k%10==0:
#print filename
num = 0
img=imutils.resize(fgmask,width=500)
#print 'img',img
filenametv=path+'lasttv.png' #用来比较的前一帧图片的文件名
#print filenametv
if os.path.exists(filenametv):
img2=cv2.imread(filenametv,0)
#print 'img2',img2
else:
cv2.imwrite(filenametv,img)
img2 = img
img3=img
img4=img2
#print 'img3',img3,img3.shape[:2]
#print 'img4',img4,img4.shape[:2]
frameDelta = cv2.absdiff(img3,img4)
#frameDelta=img3-img4
#cv2.imwrite(namedelta, frameDelta)
(h,w)=frameDelta.shape[:2]
print h,w
frameDelta = cv2.threshold(frameDelta,128,255,cv2.THRESH_BINARY)
#print frameDelta[1]
for i in range(h):
for j in range(w):
if frameDelta[1][i][j]>100:
num+=1
print num
if float(num)/(w*h)>0.01:
cv2.imwrite(filename,frame)
cv2.imwrite(filenametv,img)
def maincv2(path):
k=1
fgbg = cv2.createBackgroundSubtractorKNN()
while True:
filename=path+'njue-108-'+str(k)+'.jpeg'
frame = cv2.imread(filename)
print 'k',k
time.sleep(1)
k=k+1
#frame = imutils.resize(frame, width=int(800))
fgmask = fgbg.apply(frame)
nametv = path+'imagetv'+str(k)+'.png'
#namedelta = path+'imagedelta'+str(i)+'.png'
#cv2.imwrite(nametv, fgmask)
num = 0
img=fgmask
#img=imutils.resize(fgmask,width=500)
#print 'img',img
filenametv=path+'lasttv.png' #用来比较的前一帧图片的文件名
#print filenametv
if os.path.exists(filenametv):
img2=cv2.imread(filenametv,0)
#print 'img2',img2
else:
cv2.imwrite(filenametv,img)
img2 = img
img3=img
img4=img2
#print 'img3',img3,img3.shape[:2]
#print 'img4',img4,img4.shape[:2]
frameDelta=cv2.absdiff(img3,img4)
(h,w)=frameDelta.shape[:2]
print h,w
frameDelta = cv2.threshold(frameDelta,128,255,cv2.THRESH_BINARY)
#print frameDelta[1]
for i in range(h):
for j in range(w):
if frameDelta[1][i][j]>100:
num+=1
print (num)
print w*h
if float(num)/(w*h)<0.02:
os.remove(filename)
else:
cv2.imwrite(filenametv,img)
def procces(self):
cap = cv2.VideoCapture(0)
#o BG subtraction KNN funcionou melhor nos meus testes
#fgbg = cv2.createBackgroundSubtractorMOG2()
fgbg = cv2.createBackgroundSubtractorKNN()
firstFrame = None
count = 0
aaa = np.zeros((300,512,3), np.uint8)
cv2.namedWindow('slider')
cv2.createTrackbar("Gauss", "slider", 1, 25, self.callback_gauss)
cv2.createTrackbar("thresh1", "slider", 1, 255, self.callback_thresh1)
cv2.createTrackbar("thresh2", "slider", 1, 255, self.callback_thresh2)
while(True):
#Como o obturador das cameras demora um pouco para se adaptar espero a aquisicao de alguns frames
#antes de comecar o processamento das imagens
if count == 15:
ret, frame = cap.read()
#Nao sei pq minha webcam pegava a imagem invertida
#Se ficar de ponta cabeca remova essa linha
frame = cv2.flip(frame,0)
#Defino o primeiro frame como o demonstrativo para o Heat Map
if firstFrame == None:
firstFrame = frame
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#Existem algumas opcoes de filtro passa-baixo, estou utilziando a MedianBlur pois esse metodo
#preserva as bordas da imagem ao contrario do GaussianBlur
Gauss = cv2.GaussianBlur(gray, (self.gauss, self.gauss), 0)
thresh = cv2.threshold(Gauss, self.thresh1, self.thresh2, cv2.THRESH_BINARY)[1]
cv2.imshow("slider", Gauss)
cv2.imshow("thresh", thresh)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
else:
count += 1
cap.release()
cv2.destroyAllWindows()
def __init__(self, subMethod, display_image, acc, thresh, moghistory, mogvariance):
##Subtractor Method
self.subMethod = subMethod
####Create Background Constructor
if self.subMethod in ["Acc", "Both"]:
self.running_average_image = np.float32(display_image)
self.accAvg = acc
self.threshT = thresh
if self.subMethod in ["MOG", "Both"]:
# MOG method creator
self.fgbg = cv2.createBackgroundSubtractorMOG2(history=moghistory, detectShadows=False)
if self.subMethod == "KNN":
# MOG method creator
self.fgbg = cv2.createBackgroundSubtractorKNN()
def maincv2(path):
#print path
i =0 #i记录帧数
vcap = cv2.VideoCapture(path) #读取图片序列
print vcap.read()
fgbg = cv2.createBackgroundSubtractorKNN() #用混合高斯模型背景建模
while True:
ret, frame = vcap.read()
print frame
fgmask = fgbg.apply(frame) #获得前景（灰度图像）
'''
cv2.imshow('fgmask', fgmask)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
'''
print ret
if ret:
name = 'nn'
i+=1
print i
if i%1==0:
name = str(path[:-11])+'image'+str(i)+'.png'
print name
picdir,picname = os.path.split(name)
#print picdir
ISOTIMEFORMAT='%Y-%m-%d %X'
newname=picdir+'/'+str(time.strftime( ISOTIMEFORMAT, time.localtime() ))+'.png'
print newname
os.rename(name,newname)
print name
nametv = str(path[:-11])+'imagetv'+str(i)+'.png'
namedelta = str(path[:-11])+'imagedelta'+str(i)+'.png' #获得nametv和namedelta的路径
#print nametv
#print namedelta
#cv2.imwrite(name, frame) #将当前帧写入name
cv2.imwrite(nametv, fgmask) #将当前帧的二值图像写入nametv
test(path, newname, nametv, namedelta) #差帧
def run(self):
print('b')
#cap = cv2.VideoCapture('D:\\Work_Documents\\sandbox\\OpenCV\\with_EEN\\viaVLC\\EN-CDUM-002a+2016-08-29+14-38-40.mp4') #Open video file
cap = cv2.VideoCapture(
'http://*****:*****@192.168.11.3:10226/snapshot.cgi?.mjpeg')
#cap = cv2.VideoCapture('http://127.0.0.1:8080')
fps = 15 #int(cap.get(5)+4)
print('Current FPS is ' + str(fps))
#cv2.ocl.setUseOpenCL(False)
fgbg = cv2.createBackgroundSubtractorKNN(
detectShadows=True) # 背景差分の取得にk近傍法(kNN法)を用いる
# initialize var and windows
itr = 0
font = cv2.FONT_HERSHEY_SIMPLEX
old_center = np.empty((0, 2), float)
detect_state = np.zeros(60, dtype=np.int)
detect_state_point = 0
count = 0
self.now_count = 0
'''
cv2.namedWindow("Frame", cv2.WINDOW_KEEPRATIO | cv2.WINDOW_NORMAL)
cv2.namedWindow("Background Substraction", cv2.WINDOW_KEEPRATIO | cv2.WINDOW_NORMAL)
cv2.namedWindow("Contours", cv2.WINDOW_KEEPRATIO | cv2.WINDOW_NORMAL)
'''
# define functions
def padding_position(x, y, w, h, p): # 矩形の上下左右にpだけ広げる
return x - p, y - p, w + p * 2, h + p * 2
# find a nearest neighbour point
def serchNN(p0, ps):
L = np.array([])
for i in range(ps.shape[0]):
L = np.append(L, np.linalg.norm(ps[i] - p0))
return ps[np.argmin(L)]
# 2つのベクトルが交差しているかを判定する。
# 2つのベクトルが交差している場合、互いに自身のベクトルから見てもう一つのベクトルの両端は左右に存在することになる。
# つまり、自身のベクトルと、自身の始点からもう一つのベクトルの両端へのベクトルの外積は必ず正・負になり、その積は必ず負になる。
# 両方のベクトルでその計算をし、両方負になれば2つのベクトルは交差していると言える。
def intersect_direction(ap1, ap2, bp1, bp2):
cross1 = np.cross(ap2 - ap1, bp1 - ap1)
cross2 = np.cross(ap2 - ap1, bp2 - ap1)
calc1 = cross1 * cross2
if (calc1 < 0):
calc2 = np.cross(bp2 - bp1, ap1 - bp1) * np.cross(
bp2 - bp1, ap2 - bp1)
if (calc2 < 0):
return 1 if cross1 < 0 else -1 #交差した場合、左から右に通過した場合は1、右から左に通過した場合は-1を返す。
return 0
# 直前のフレームでの動体検知状態を保持しておき、現在動体が存在するかどうか決定する。
# 要はチャタリング防止用関数。
def detected(detect_cnt):
global detect_state
global detect_state_point
detect_state[detect_state_point] = detect_cnt
if detect_state_point != detect_state.shape[0] - 1:
detect_state_point = detect_state_point + 1
else:
detect_state_point = 0
if detect_state.shape[0] // 2 <= detect_state.sum():
return True
else:
return False
# apply convexHull to the contour
def convHull(cnt):
epsilon = 0.1 * cv2.arcLength(cnt, True) # 領域を囲む周囲長を計算
approx = cv2.approxPolyDP(
cnt, epsilon,
True) # 領域の形状に近似した形状を取得、epsilonが小さければ小さいほど近似の精度が高くなる
hull = cv2.convexHull(
cnt, returnPoints=True) # 凸包(図形を紐で囲い締め上げたときに取る形状)を取得
return hull
# detect a centroid from a coutour
def centroidPL(cnt):
M = cv2.moments(cnt) # モーメントを取得
cx = int(M['m10'] / M['m00']) # モーメントから重心のx軸を計算
cy = int(M['m01'] / M['m00']) # モーメントから重心のy軸を計算
return cx, cy
# display 1st frame and set counting line
ret, img = cap.read()
img = cv2.resize(img, (img.shape[1] // 2, img.shape[0] // 2))
imgr = img.copy() # 参照型のため同じオブジェクトを参照しないようコピー
sx, sy = -1, -1
ex, ey = -1, -1
def draw_line(event, x, y, flags, param): # ドラッグの始点から終点に直線を引く
global sx, sy, ex, ey
if event == cv2.EVENT_LBUTTONDOWN:
sx, sy = x, y
elif event == cv2.EVENT_LBUTTONUP:
cv2.line(img, (sx, sy), (x, y), (255, 0, 0), 2)
ex, ey = x, y
# initialize line
lp0 = (sx, sy)
lp1 = (ex, ey)
nlp0 = np.array([lp0[0], lp0[1]], float)
nlp1 = np.array([lp1[0], lp1[1]], float)
while (cap.isOpened()):
count = 0
try:
ret, o_frame = cap.read() #read a frame
frame = cv2.resize(
o_frame, (o_frame.shape[1] // 2, o_frame.shape[0] // 2))
#Use the substractor
fgmask = fgbg.apply(frame) #現在のシーンをkNN法でグレースケール化する？
fgmask_o = fgmask.copy()
fgmask = cv2.threshold(
fgmask, 244, 255,
cv2.THRESH_BINARY)[1] #グレースケール化された画像を2値化する？
# kernel = np.ones((5,5), np.uint8)
# fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_CLOSE, kernel)
# cv2.dilate(入力画像, カーネル, 繰り返し回数) 画像のモルフォロジー変換(膨張処理)
fgmask = cv2.dilate(
fgmask,
cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)),
iterations=2) # 2値化された画像の白い箇所を円形カーネルで2回膨張(Dilation)させる?
# cv2.findContours(入力画像, 抽出モード, 近似法) 画像の輪郭抽出
im2, contours, hierarchy = cv2.findContours(
fgmask, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE) # 抽出モードを最も外側の輪郭のみに設定し、簡略化した頂点数で囲う
# initialize var iteration
new_center = np.empty(
(0, 2), float
) # 配列の生成速度が若干高速になることがあるため、値を0や1で初期化する必要のない場合は、np.emptyを使う
for c in contours:
if (itr % fps == 0
): #これ15フレームに一回の処理じゃなくて、15回の動画読み込みに1回処理スキップしてるだけじゃね？
continue
# calc the area
cArea = cv2.contourArea(c) # 領域が占める面積を計算
if cArea < 1000: # if 1280x960 set to 50000, 640x480 set to 12500 面積が小さすぎたら処理をスキップ
continue
# apply the convex hull
c = convHull(c) # 領域の凸包を取得
# rectangle area
x, y, w, h = cv2.boundingRect(c) # 領域の矩形の左上のポイントと幅、高さを取得
x, y, w, h = padding_position(x, y, w, h,
5) # 矩形の上下左右に5だけ広げる
# center point
cx, cy = centroidPL(c) # 領域の重心点を取得
new_point = np.array([cx, cy], float)
new_center = np.append(new_center,
np.array([[cx, cy]]),
axis=0) # 行方向に重心点を追加
if (old_center.size > 1):
#print cArea and new center point
print('Loop: ' + str(itr) + ' Coutours #: ' +
str(len(contours)))
print('New Center :' + str(cx) + ',' + str(cy))
#print 'New Center :' + str(new_center)
# calicurate nearest old center point
old_point_t = serchNN(new_point, old_center)
# check the old center point in the counding box
if (cv2.pointPolygonTest(
c,
(old_point_t[0], old_point_t[1]), True) > 0):
old_point = old_point_t
print('Old Center :' + str(int(old_point[0])) +
',' + str(int(old_point[1])))
# put line between old_center to new_center
cv2.line(frame,
(int(old_point[0]), int(old_point[1])),
(cx, cy), (0, 0, 255), 2)
count = 1
# put floating text
cv2.putText(frame, 'CA:' + str(cArea)[0:-2],
(x + 10, y + 20), font, 0.5, (255, 255, 255),
1, cv2.LINE_AA)
# draw center
cv2.circle(frame, (cx, cy), 5, (0, 0, 255), -1)
# draw rectangle or contour
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0),
3) #rectangle contour
# cv2.drawContours(frame, [c], 0, (0,255,0), 2)
# cv2.polylines(frame, [c], True, (0,255,0), 2)
# put fixed text, line and show images
if detected(count) == True:
cv2.putText(frame, 'Detect!',
((o_frame.shape[1] // 6), 30), font, 1,
(255, 255, 255), 1, cv2.LINE_AA)
self.now_count = 1
else:
self.now_count = 0
cv2.line(frame, (lp0), (lp1), (255, 0, 0), 2)
cv2.imshow('Frame', frame)
cv2.imshow('Background Substraction', fgmask_o)
cv2.imshow('Contours', fgmask)
# increase var number and renew center array
old_center = new_center
itr += 1
except:
#if there are no more frames to show...
print('EOF')
break
#Abort and exit with 'Q' or ESC
k = cv2.waitKey(30) & 0xff
if k == 27:
break
cap.release() #release video file
cv2.destroyAllWindows() #close all openCV windows
def detection_settings(
self,
skip=5,
warmup=0,
start_after=0,
finish_after=0,
history=60,
threshold=10,
detect_shadows=True,
mode="MOG",
methods=None,
c_mask=False,
c_mask_shape="rect",
c_mask_size=50,
):
"""
Set properties of output video file. Most settings can be left at their
default value.
Parameters
----------
skip: int, optional
how many frames to skip between each capture
warmup: int, optional
warmup period in seconds for the background subtractor
start_after: int, optional
start after X seconds
finish_after: int, optional
finish after X seconds
history: int, optional
how many frames to use for fg-bg subtraction algorithm
threshold: int, optional
sensitivity-level for fg-bg subtraction algorithm (lower = more
sensitive)
detect_shadows: bool, optional
attempt to detect shadows - will be returned as gray pixels
mode: {"MOG", "KNN"} str, optional
type of fg-bg subtraction algorithm
methods: method or list of methods, optional
list with tracking_method objects
c_mask: bool, optional
consecutive masking. if multiple methods are defined, the objects
detected first will mask the objects detected in subsequent methods
c_mask_shape: {"rect", "ellipse", "contour"} str, optional
which shape should the consecutive mask have
c_mask_size: int, optional
area in pixels that is added around the mask
"""
## kwargs
self.skip = skip
self.warmup = warmup
self.start = start_after
self.finish = finish_after
self.flag_detect_shadows = detect_shadows
self.flag_consecutive = c_mask
self.consecutive_shape = c_mask_shape
self.consecutive_size = c_mask_size
## select background subtractor
if mode == "MOG":
self.fgbg_subtractor = cv2.createBackgroundSubtractorMOG2(
int(history * (self.fps / self.skip)), threshold, self.flag_detect_shadows
)
elif mode == "KNN":
self.fgbg_subtractor = cv2.createBackgroundSubtractorKNN(
int(history * (self.fps / self.skip)), threshold, self.flag_detect_shadows
)
## return settings of methods
if not methods.__class__.__name__ == "NoneType":
if methods.__class__.__name__ == "tracking_method":
methods = [methods]
self.methods = methods
for m in self.methods:
m._print_settings()
print("\n")
print("--------------------------------------------------------------")
print('Motion detection settings - "' + self.name + '":\n')
print(
"Background-subtractor: "
+ str(mode)
+ "\nHistory: "
+ str(history)
+ " seconds"
+ "\nSensitivity: "
+ str(threshold)
+ "\nRead every nth frame: "
+ str(self.skip)
+ "\nDetect shadows: "
+ str(self.flag_detect_shadows)
+ "\nStart after n seconds: "
+ str(self.start)
+ "\nFinish after n seconds: "
+ str(self.finish if self.finish > 0 else " - ")
)
print("--------------------------------------------------------------")
import numpy as np
import cv2
from shapely.ops import cascaded_union
import shapely.geometry as sg
cap = cv2.VideoCapture('C:/Users/Ben/Desktop/MeerkatTest/garcon_test.avi')
#cap = cv2.VideoCapture('C:/Users/Ben/Documents/OpenCV_HummingbirdsMotion/testing/PlotwatcherTest.TLV')
#cap=cv2.VideoCapture("F:/FieldWork2013/Santa Lucia 1/HDV_0316.mp4")
#fgbg5000 = cv2.createBackgroundSubtractorMOG2(500, 16,detectShadows = False)
fgbg1000 = cv2.createBackgroundSubtractorKNN()
for x in np.arange(0,1000):
cap.grab()
def cont(orig,fram):
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(7,7))
fr=fram.copy()
morph=orig.copy()
poly=orig.copy()
width = np.size(fr, 1)
height = np.size(fr, 0)
# Now calculate movements using the white pixels as "motion" data
_,contours,hierarchy = cv2.findContours(fr, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE )
top = 0
#生成视频的背景建模->黑白图像，但只有显示，没有保存文件，需要截屏
import cv2 as cv
import numpy as np
# 加载视频
cap = cv.VideoCapture(
r"C:\Users\ningningbeibei33\Desktop\graduate\1\a\b\c\data\lift_video_10_2.mp4"
)
# 创建混合高斯模型用于背景建模
background_model = cv.createBackgroundSubtractorKNN(
) #或者使用cv.createBackgroundSubtractorMOG2()
background_model = cv.createBackgroundSubtractorMOG2()
# 形态学操作核
kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, (3, 3))
fourcc1 = cv.VideoWriter_fourcc(*'XVID')
fps1 = cap.get(cv.CAP_PROP_FPS)
size1 = (int(cap.get(cv.CAP_PROP_FRAME_WIDTH)),
int(cap.get(cv.CAP_PROP_FRAME_HEIGHT)))
out1 = cv.VideoWriter(
"C:/Users/ningningbeibei33/Desktop/graduate/1/a/b/c/data/back_ground/BackgroundSubtractorKNN.avi",
fourcc1, fps1, size1)
step = 0
while True:
# 读取下一帧图像
ret, frame = cap.read()
# 更新模型参数，对预测结果进行开运算
fgmask = background_model.apply(frame)
fgmask = cv.morphologyEx(fgmask, cv.MORPH_OPEN, kernel)
# 轮廓筛选：人
def main():
# ####upper and lower bounds for colors
# yellow bounds from:
# https://stackoverflow.com/questions/9179189/detect-yellow-color-in-opencv
camera = cv2.VideoCapture(0)
vs = WebcamVideoStream(src=0).start()
lower_blue = np.array([110, 50, 50])
upper_blue = np.array([130, 255, 255])
lower_yellow = np.array([20, 100, 100])
upper_yellow = np.array([30, 255, 255])
grabBackground = 0;
fgbg = None;
reduction =None
background = None
grabbed = False
while True:
img_frame = vs.read()
# set up img_frame for masking
img_frame = imutils.resize(img_frame, width=900)
img_frame = cv2.flip(img_frame, 1)
blah = img_frame.copy()
if (grabBackground <30):
grabBackground += 1
elif not grabbed:
fgbg = cv2.createBackgroundSubtractorKNN()
background = img_frame.copy()
grabbed = True
# create mask to block out all colors but blue
if fgbg != None:
img_frame = fgbg.apply(img_frame)
if background != None:
res = cv2.subtract(background,blah)
else: res = img_frame.copy()
res = cv2.erode(res, None, iterations=1)
res = cv2.dilate(res, None, iterations=1)
img_frame = cv2.erode(img_frame, None, iterations=2)
img_frame = cv2.dilate(img_frame, None, iterations=2)
if grabbed:
contours = cv2.findContours(img_frame.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)[-2]
center = None
# only proceed if at least one contour was found
if grabbed and (len(contours) > 0):
# find the largest contour in the mask, then use
# it to compute the minimum enclosing circle and
# centroid
c = max(contours, key=cv2.contourArea)
((x, y), radius) = cv2.minEnclosingCircle(c)
M = cv2.moments(c)
center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"]))
# only proceed if the radius meets a minimum size
if radius > 10:
# draw the circle and centroid on the img_frame,
# then update the list of tracked points
cv2.circle(img_frame, (int(x), int(y)), int(radius),
(255, 255, 255), 2)
cv2.circle(img_frame, center, 5, (255, 255, 255), -1)
cv2.imshow("other", res)
cv2.imshow("Frame", img_frame)
key = cv2.waitKey(1) & 0xFF
# if the 'q' key is pressed, stop the loop
if key == ord("q"):
break
# cleanup the camera and close any open windows
camera.release()
cv2.destroyAllWindows()
vs.stop()
def main():
number_of_watch_point = 4
myrover = RoverSignFollower()
myrover.turnLightsOn()
signal.signal(signal.SIGINT, _signal_handler)
print("Battery at " + str(myrover.getBatteryPercentage()) + "%"
) #Check battery status
IMAGE_PATHS = [[] for _ in xrange(number_of_watch_point)]
current_watch_point = 0
time.sleep(2)
sign_counter = 0
break_point = 0
while True:
try:
while True:
x, y, w, h, image, cnt = myrover.detect_blue_sign(
myrover.getImageName())
gap = myrover.compare_centroids('tmp.jpg', x, y, w, h)
if abs(
gap
) > 10: # Orient towards the center of the sign and move towards it.
if gap < 0:
myrover.turn(gap * TURN_VALUE)
if gap > 0:
myrover.turn(gap * TURN_VALUE)
if w * h < 29000: # Keep moving till the sign is big enough to read the command.
myrover.moveForward(0.2, 0.5)
time.sleep(0.1)
else:
x, y, w, h, action_image, action_cnt = myrover.detect_blue_sign(
myrover.getImageName())
gap = myrover.compare_centroids('tmp.jpg', x, y, w, h)
bs_img = action(x, y, w, h, action_image, action_cnt)
if np.count_nonzero(bs_img) > 300000:
IMAGE_PATHS[current_watch_point].append(bs_img)
break_point = break_point + 1
print break_point
if break_point > 30:
break_point = 0
break
fgbg = cv2.createBackgroundSubtractorKNN()
fgbg2 = cv2.createBackgroundSubtractorMOG2()
# Background subtraction
for iter in xrange(len(IMAGE_PATHS[current_watch_point])):
frame = IMAGE_PATHS[current_watch_point][iter]
frame2 = frame.copy()
#cv2.imshow('frame', frame)
fgmask = fgbg.apply(frame)
fgmask2 = fgbg2.apply(frame2)
#cv2.imshow('frame with KNN', fgmask)
#cv2.imshow('frame with MOG', fgmask2)
alarm = np.count_nonzero(fgmask)
if alarm > 4000:
img = cv2.imread("warning.jpg")
cv2.imshow("warning.jpg", img)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
print 'shot'
current_watch_point = (current_watch_point +
1) % number_of_watch_point
myrover.turn(165)
time.sleep(2)
except:
traceback.print_exc()
print("No Purple sign detected")
#myrover.moveForward(0.2,-0.2) # If no blue sign detected, move forward a little and look again.
sign_counter += 1
if sign_counter > 3:
sign_counter = 0
myrover.moveForward(0.5, -0.5)
import cv2
import numpy as np
bs = cv2.createBackgroundSubtractorKNN(detectShadows=False)
history = 30
bs.setHistory(history)
frames = 0
camera = cv2.VideoCapture("##.mp4")
count = 0
while True:
ret, frame = camera.read()
if ret == True:
fgmask = bs.apply(frame)
if frames < history:
frames += 1
continue
print('Read a new frame: ', ret)
th = cv2.threshold(fgmask.copy(), 244, 255, cv2.THRESH_BINARY)[1]
th = cv2.erode(th,
cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)),
iterations=None)
dilated = cv2.dilate(th,
cv2.getStructuringElement(cv2.MORPH_ELLIPSE,
(3, 3)),
iterations=None)
contours, hier = cv2.findContours(dilated, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
for c in contours:
area = cv2.contourArea(c)
if area < 50:
def run(self,
images: np.ndarray,
video_start_indices: list,
load=False,
apply_post=False,
history=40,
dist2Threshold=300,
detectShadows=False):
"""
Try loading the data
If there is nothing to load, we have to manually go through the process
:param images:
:param video_start_indices:
:return:
"""
self.segmented_images = None
self.logger.info(
"Starting Background Subtraction on given Video Dataset...")
if load:
self.logger.info("Trying to load from saved file....")
self._loadSegmentedImages()
if self.segmented_images is None:
# fgbg only takes grayscale images, we need to convert
## check if image is already converted to grayscale -> channels = 1
if images.ndim > 3:
self.logger.info(f"Data is not grayscale, converting....")
images_gray = (np.mean(images, axis=3)).astype(np.uint8)
else:
self.logger.info("Data is grayscale!")
images_gray = images
segmented_images = np.ndarray(shape=images_gray.shape,
dtype=np.uint8)
for i in range(len(video_start_indices) - 1):
# start index is inclusive, end index is not inclusive
start_index = video_start_indices[i]
end_index = video_start_indices[i + 1]
self.logger.debug(
f"start index: {start_index}, end index: {end_index}")
fgbg = cv2.createBackgroundSubtractorKNN(
history=history,
dist2Threshold=dist2Threshold,
detectShadows=detectShadows)
# first round is to tune the values of the background subtractor
for ii in range(start_index, end_index):
fgbg.apply(images_gray[ii])
# second round is to extract the masked values
for ii in range(start_index, end_index):
segmented_images[ii] = fgbg.apply(images_gray[ii])
self.logger.debug(
f"Video {i} done! Processed {end_index - start_index} images"
)
if apply_post:
self.logger.debug(
"Applying post additional computer vision methods to background subtracted images..."
)
self.segmented_images = self._postfgbg(segmented_images)
else:
self.segmented_images = segmented_images
return self.segmented_images
tstart = 0.0
history = 400
dist2Threshold = 200.0
detectShadows = False
cx = 0
cy = 0
c = 0
x = 0
y = 0
dH = 0
dV = 0
thetaH = 14.68
thetaV = 10.5
Hpx = 640.0
Vpx = 480.0
fgbg = cv2.createBackgroundSubtractorKNN(history, dist2Threshold,
detectShadows)
#fgbg = cv2.cudabgsegm.createBackgroundSubtractorMOG(history,nmixtures,backgroundRatio,noiseSigma)
# Small helper function to display opencv buffers via GStreamer.
#
# The display_buffers list holds references to the buffers we pass down to
# Gstreamer. This is required because otherwise python would free the memory
# before we displayed it and we do not want to copy the data to an allocated
# buffer.
display_buffers = []
def show_img(display_input, img):
global display_buffers
bytebuffer = img.tobytes()
import cv2
import numpy as np
video_file = "Propellers_Video.avi" #test video
kernel_dil = np.ones((20, 20), np.uint8)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
fgbg = cv2.createBackgroundSubtractorKNN() #Background Subtraction function
cap = cv2.VideoCapture(video_file)
#cap = cv2.VideoCapture(0) for taking input from computer’s camera
while True:
ret, frame = cap.read()
fshape = frame.shape
frame = frame[1:fshape[0] - 2, :fshape[1] - 2, :] #cropping the video size
#print frame.shape
if ret == True:
fgmask = fgbg.apply(frame)
fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_OPEN, kernel)
dilation = cv2.dilate(fgmask, kernel_dil, iterations=1)
(contours, hierarchy) = cv2.findContours(dilation, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
for pic, contour in enumerate(contours):
area = cv2.contourArea(contour)
import cv2 as cv
cap = cv.VideoCapture(0) # 0 means 1st camera, 1 means 2nd cam
bgmask = cv.createBackgroundSubtractorKNN()
while True:
ret, frame =cap.read()
if not ret:
print('camera not working')
break
mask = bgmask.apply(frame)
cv.imshow('thats me',frame)
cv.imshow('thats me masked',mask)
if cv.waitKey(1) == 27:
break
cap.release()
cv.destroyAllWindows()
def main():
cap = cv2.VideoCapture(1)
fgbg = cv2.createBackgroundSubtractorKNN()
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
kernel_l = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9))
kernel_s = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
b = 7
ret, bg = cap.read()
gbg = cv2.cvtColor(bg, cv2.COLOR_BGR2GRAY)
gbg_blur = cv2.GaussianBlur(gbg, (b, b), 0)
bg_blur = cv2.GaussianBlur(bg, (b, b), 0)
k = 0
while (True):
if k == 0:
ret, bg = cap.read()
gbg = cv2.cvtColor(bg, cv2.COLOR_BGR2GRAY)
gbg_blur = cv2.GaussianBlur(gbg, (b, b), 0)
bg_blur = cv2.GaussianBlur(bg, (b, b), 0)
k = (k + 1) % 60
ret, frame = cap.read()
im = frame.copy()
gim = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
gim_blur = cv2.GaussianBlur(gim, (b, b), 0)
im_blur = cv2.GaussianBlur(im, (b, b), 0)
res = cv2.absdiff(im_blur, bg_blur)
gres = cv2.absdiff(gim_blur, gbg_blur)
gres = cv2.cvtColor(res, cv2.COLOR_BGR2GRAY)
ret, mres = cv2.threshold(gres, 25, 255, cv2.THRESH_BINARY)
for i in range(0, 3):
ret, m = cv2.threshold(res[:, :, i], 25, 255, cv2.THRESH_BINARY)
mres = cv2.max(mres, m)
gres = cv2.cvtColor(gres, cv2.COLOR_GRAY2BGR)
mres = cv2.cvtColor(mres, cv2.COLOR_GRAY2BGR)
mres = cv2.morphologyEx(mres, cv2.MORPH_OPEN, kernel)
mres = cv2.morphologyEx(mres, cv2.MORPH_CLOSE, kernel)
fgmask = fgbg.apply(im)
fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_OPEN, kernel)
fgmask = cv2.morphologyEx(fgmask, cv2.MORPH_CLOSE, kernel)
fgmask = cv2.cvtColor(fgmask, cv2.COLOR_GRAY2BGR)
# Display the resulting frame
fg = im.astype(float)
alpha = fgmask.astype(float) / 100
fg = cv2.multiply(alpha, fg) / 255
stacked = np.hstack((fg, mres))
cv2.imshow('frame', stacked)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
def genetic(gen, child, attrib):
name = "gen" + str(gen) + "," + str(child)
cap = cv2.VideoCapture()
#http://www.chart.state.md.us/video/video.php?feed=13015dbd01210075004d823633235daa
#Use this until we find a better traffic camera
cap.open('./highway/input/in%06d.jpg')
w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
#bg subtractor
fgbg = cv2.createBackgroundSubtractorKNN()
#parameters for blob detector
params = cv2.SimpleBlobDetector_Params()
params.minThreshold = attrib['minT']
params.maxThreshold = attrib['maxT']
params.filterByArea = True
params.minArea = attrib['minA']
params.maxArea = attrib['maxA']
params.filterByConvexity = True
params.minConvexity = attrib['minCov']
detector = cv2.SimpleBlobDetector_create(params)
cv2.namedWindow(name, cv2.WINDOW_NORMAL)
cv2.resizeWindow(name, w, h)
confmat = np.zeros((2,2))
out = 1
score = float(0)
while(cap.isOpened()):
ret, frame = cap.read()
if ret == True:
if(confmat[0][1] != 0 and confmat[1][0] != 0):
score = confmat[0][0]/float(confmat[0][0]+confmat[1][0])+\
confmat[0][0]/float(confmat[0][0]+confmat[0][1])
#bg subtract
img1 = fgbg.apply(frame)
#white bg for bbox
imgbbox = sp.ones((240,320), sp.uint8) * 255
#invert image
cv2.bitwise_not(img1, img1)
#gaussian
img1 = cv2.GaussianBlur(img1,(attrib['filt'], attrib['filt']),
attrib['sigma'])
#blob detect
points = detector.detect(img1)
#draw bounding boxes
for p in points:
x1 = int(p.pt[0]-p.size/2)
y1 = int(p.pt[1]-p.size/2)
x2 = int(p.pt[0]+p.size/2)
y2 = int(p.pt[1]+p.size/2)
cv2.rectangle(img1,(x1,y1),(x2,y2),1)
cv2.rectangle(imgbbox,(x1,y1),(x2,y2),(0,0,0),cv2.FILLED)
#load gt in grayscale
img_gt = cv2.imread("./highway/groundtruth/gt"+str(out).zfill(6)+".png", 0)
cv2.bitwise_not(img_gt, img_gt)
#everything in gt before 470 is blank
if (out > 470):
#comparing every 5x, 5y
for x in range(0,len(img_gt),5):
for y in range(0,len(img_gt[x]),5):
if (img_gt[x][y] == 0 and imgbbox[x][y] == 0):
confmat[0][0] = confmat[0][0] + 1 #TP
elif (img_gt[x][y] != 0 and imgbbox[x][y] == 0):
confmat[0][1] = confmat[0][1] + 1 #FP
elif (img_gt[x][y] == 0 and imgbbox[x][y] != 0):
confmat[1][0] = confmat[1][0] + 1 #FN
strinfo = 'Gen: %(gen)d, Child: %(ch)d' % {"gen":gen, "ch":child}
cv2.putText(img1, strinfo, (5,235),0,0.4, 0);
strscore = 'Score: %(sc).5f' % {"sc": score}
cv2.putText(img1, strscore, (5,12),0,0.4, 0);
cv2.imshow(name, img1)
#cv2.waitKey(67) waits for 0.067 seconds making this ~15fps
#Stop loop with "q"
if cv2.waitKey(1) & 0xFF == ord('q'):
break
out = out + 1
else: break
#returns precision + recall
return score
cap.release()
parser = arg.ArgumentParser()
parser.add_argument('--inputPath',
help="path to input Video",
default='resources/MVI_9105.MOV')
args = parser.parse_args()
log.info("Video Path : '{}'".format(args.inputPath))
'-------------------------------------------------------------------------------------'
'Video Capture Init'
capture = cv.VideoCapture(args.inputPath)
capture2 = cv.VideoCapture(args.inputPath)
'Background substraction init'
backSub = cv.createBackgroundSubtractorKNN(history=200,
dist2Threshold=500.0,
detectShadows=False)
'Get Video Properties'
frame_count = capture.get(cv.CAP_PROP_FRAME_COUNT)
frame_width = capture.get(cv.CAP_PROP_FRAME_WIDTH)
frame_height = capture.get(cv.CAP_PROP_FRAME_HEIGHT)
fps = capture.get(cv.CAP_PROP_FPS)
video_codec = capture.get(cv.CAP_PROP_FOURCC)
video_name = args.inputPath.split(".")[0].split("/")[1]
'Log Properties'
log.info("Total Number of Frames : '{}'".format(frame_count))
log.info("Frame width : '{}'".format(frame_width))
log.info("Frame height : '{}'".format(frame_height))
log.info("FPS : '{}'".format(fps))
info = x, y, vid.get(1)
wr.writerow(info)
# wr.writerow([position, vid.get(1)])
resultFile.flush()
print(position)
elif event == cv2.EVENT_LBUTTONUP:
drawing = False
if event == cv2.EVENT_MOUSEMOVE:
posmouse = (x, y)
vid = cv2.VideoCapture(args['video'])
fgbg = cv2.createBackgroundSubtractorKNN(history=5000,
dist2Threshold=225,
detectShadows=False)
Nframes = vid.get(7)
print("Total number of frames = " + str(Nframes))
while (vid.isOpened()):
ret, frame = vid.read()
frame2 = cv2.resize(frame, (1440, 810))
hsl = cv2.cvtColor(frame2, cv2.COLOR_BGR2HLS_FULL)
one, two, three = cv2.split(hsl)
blobs = fgbg.apply(two)
blobs = cv2.erode(blobs, (3, 3), iterations=1)
res = cv2.bitwise_or(blobs, two)
2,
np.pi / 180,
100,
np.array([]),
minLineLength=20,
maxLineGap=5)
return lines
def image_copy(image):
lane_image = np.copy(image)
cropped_image = region_of_intrest(lane_image)
line_image = display_lines(lane_image, lines(cropped_image))
combo_image = cv2.addWeighted(lane_image, 0.8, line_image, 1, 1)
return combo_image
cap = cv2.VideoCapture('test6.mp4')
forback = cv2.createBackgroundSubtractorKNN()
while (cap.isOpened()):
_, frame = cap.read()
fgmask = forback.apply(canny(frame))
cv2.imshow('FG mask Frame', image_copy(fgmask))
if cv2.waitKey(1) == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
if len(sys.argv) < 2:
print 'Usage: ./opencv_background_subtraction_play.py [VIDEO]'
sys.exit(1)
video_capture = cv2.VideoCapture(sys.argv[1])
if not video_capture.isOpened():
print 'Video file could not be opened.'
sys.exit(1)
# If the frame size is too large for the monitor, we can resize the window.
cv2.namedWindow('Window', cv2.WINDOW_NORMAL)
cv2.resizeWindow('Window', int(video_capture.get(cv2.CAP_PROP_FRAME_WIDTH)/2),
int(video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT)/2))
num_frames = video_capture.get(cv2.CAP_PROP_FRAME_COUNT)
knn = cv2.createBackgroundSubtractorKNN()
frame_idx = 0
while frame_idx < num_frames:
ret, frame = video_capture.read()
frame_idx += 1
if not ret:
print 'Frame %d could not be read properly.' % frame_idx
sys.exit(1)
bgs_frame = knn.apply(frame, 0)
cv2.putText(bgs_frame, str(frame_idx), (20, 100), cv2.FONT_HERSHEY_SIMPLEX, 2,
(255, 255, 255))
cv2.imshow('Window', bgs_frame)
import cv2
#cap=cv2.VideoCapture('vtest.avi')
import sys
import video
try:
fn = sys.argv[1]
except IndexError:
fn = 0
cap = video.create_capture(fn)
#MOG MOG2 GMG KNN
#fgbg = cv2.createBackgroundSubtractorMOG2()
kernal = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (4, 4))
fgbg = cv2.createBackgroundSubtractorKNN(detectShadows=None)
while (cap.isOpened()):
_, img = cap.read()
frame = fgbg.apply(img)
# frame = cv2.morphologyEx(frame,cv2.MORPH_OPEN
# ,kernal)
cv2.imshow('image', img)
cv2.imshow('subtraced', frame)
if cv2.waitKey(30) == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
except AttributeError:
warnings.warn(
"BackgroundSubtractorMOG2 does not exist in your OpenCV {}".format(
cv2.__version__))
"""
BSubtractorKNN
"""
params = np.linspace(1, 100, 20)
x_mask = []
print("\n\nBackgroundSubtractorKNN Method (from OpenCV {})".format(
cv2.__version__))
try:
bg_substractor = cv2.BackgroundSubtractorKNN()
for id, p in enumerate(params):
bg_substractor = cv2.createBackgroundSubtractorKNN(
history=0, dist2Threshold=p, detectShadows=False)
x_mask.append(
extractBackgroundSubtrasctor_CV(bg_substractor,
data=input,
im_show=False))
sys.stdout.write("\r> Computing ... {:.2f}%".format(
(id + 1) * 100 / len(params)))
sys.stdout.flush()
print("\n")
TP_list, FP_list, TN_list, FN_list = extractPerformance(
gt, x_mask, array_params=params)
precision_list, recall_list, fscore_list, accuracy_list = metrics(
TP_list, FP_list, TN_list, FN_list, x_mask, array_params=params)
def main(input_file='vtest.avi',
heatmap_color=cv2.COLORMAP_BONE,
color_label="cv2.COLORMAP_BONE"):
print("Input source: " + input_file + " ", heatmap_color)
cap = cv2.VideoCapture(input_file)
#fgbg = cv2.bgsegm.createBackgroundSubtractorMOG()
#fgbg = cv2.createBackgroundSubtractorMOG2()
fgbg = cv2.createBackgroundSubtractorKNN()
# Debug parameters
fps = cap.get(cv2.CAP_PROP_FPS) # Frames per second
frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT) # Frame count
frame_number = 0 # Frame number
success, frame = cap.read()
first_frame = copy.deepcopy(frame)
height, width = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY).shape[:2]
accum_image = np.zeros((height, width), np.uint8)
while success and cap.isOpened():
index = 0
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # convert to grayscale
fgmask = fgbg.apply(gray) # remove the background
# for testing purposes, show the result of the background subtraction
# cv2.imshow('diff-bkgnd-frame', fgmask)
# apply a binary threshold only keeping pixels above thresh and setting the result to maxValue. If you want
# motion to be picked up more, increase the value of maxValue. To pick up the least amount of motion over time, set maxValue = 1
thresh = 2
maxValue = 2
ret, th1 = cv2.threshold(fgmask, thresh, maxValue, cv2.THRESH_BINARY)
# for testing purposes, show the threshold image
# cv2.imwrite('diff-th1.jpg', th1)
# add to the accumulated image
accum_image = cv2.add(accum_image, th1)
# for testing purposes, show the accumulated image
# cv2.imwrite('diff-accum.jpg', accum_image)
# for testing purposes, control frame by frame
# raw_input("press any key to continue")
try:
color_map_img = cv2.applyColorMap(accum_image, heatmap_color)
except TypeError:
print("Could not apply color: " + heatmap_color)
return
im0 = cv2.resize(color_map_img, (1000, 980))
font_size, font_thickness = 0.7, 2
text = color_label[4:]
x, y, w, h = 15, 30, 275, 75
# Draw black background rectangle
cv2.rectangle(im0, (x, x), (x + w, y + h), (0, 0, 0), -1)
im0 = cv2.putText(im0, text, (x + int(w / 10), y + int(h / 2)),
cv2.FONT_HERSHEY_SIMPLEX, font_size, (255, 55, 255),
font_thickness)
cv2.namedWindow(Original_WIN)
cv2.moveWindow(Original_WIN, 1080, 0)
cv2.namedWindow(Heatmap_WIN)
cv2.moveWindow(Heatmap_WIN, 20, 0)
cv2.imshow(Heatmap_WIN, im0)
cv2.imshow(Original_WIN, frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
elif cv2.waitKey(1) & 0xFF == ord('k'):
print("Terminated")
#sys.exit(0)
#print("Frame: ", frame_number)
#print("FPS: ", fps)
while frame_number < 1:
os.system("xdotool getactivewindow windowmove -- -40 0")
frame_number += 1
frame_number += 1
#cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
success, frame = cap.read()
# apply a color map
print("writing to file")
color_image = im_color = cv2.applyColorMap(accum_image, heatmap_color)
# for testing purposes, show the colorMap image
# cv2.imwrite('diff-color.jpg', color_image)
# overlay the color mapped image to the first frame
result_overlay = cv2.addWeighted(first_frame, 0.7, color_image, 0.7, 0)
# save the final overlay image
cv2.imwrite('diff-overlay.jpg', result_overlay)
# cleanup
cap.release()
cv2.destroyAllWindows()
parser.add_argument('--input',
type=str,
help='Path to a video or a sequence of image.',
default='vtest.avi')
parser.add_argument('--algo',
type=str,
help='Background subtraction method (KNN, MOG2).',
default='MOG2')
args = parser.parse_args()
## [create]
#create Background Subtractor objects
if args.algo == 'MOG2':
backSub = cv.createBackgroundSubtractorMOG2()
else:
backSub = cv.createBackgroundSubtractorKNN()
## [create]
## [capture]
capture = cv.VideoCapture(cv.samples.findFileOrKeep(args.input))
if not capture.isOpened:
print('Unable to open: ' + args.input)
exit(0)
## [capture]
while True:
ret, frame = capture.read()
if frame is None:
break
## [apply]
import numpy as np
import cv2
from PIL import ImageFont, ImageDraw, Image
def f(x): print(x)
cap = cap = cv2.VideoCapture(0)
fgbg = cv2.createBackgroundSubtractorKNN()
cv2.namedWindow('Mask')
cv2.createTrackbar('Learning rate', 'Mask', 0, 100, f)
cv2.createTrackbar('Shadow rate', 'Mask', 0, 127, f)
cv2.createTrackbar('Algorithm - 0:KNN 1:MOG2 2:CNT', 'Mask', 0, 2, f)
algorithmNumber = 0
algorithmName = 'KNN'
while(True):
ret, frame = cap.read()
learningRate = cv2.getTrackbarPos('Learning rate', 'Mask')
shadow = cv2.getTrackbarPos('Shadow rate', 'Mask')
algorithm = cv2.getTrackbarPos('Algorithm - 0:KNN 1:MOG2 2:CNT', 'Mask')
if algorithmNumber != algorithm:
if algorithm == 0:
fgbg = cv2.createBackgroundSubtractorKNN()
fgbg.setShadowValue(shadow)
algorithmName = 'KNN'
elif algorithm == 1:
fgbg = cv2.createBackgroundSubtractorMOG2()
fgbg.setShadowValue(shadow)
algorithmName = 'MOG2'
elif algorithm == 2:
import cv2
import numpy as np
import math
from scipy.spatial.distance import pdist
video = cv2.VideoCapture('/Users/itaegyeong/Desktop/good.mov')
knn = cv2.createBackgroundSubtractorKNN()
# 이전의 프레임과 비교하여 w,h 도 크게 차이나지 않으며, 거리도 가장 작은것으로 선택
# 각 선택된것은 선수 1,2,3,4,5 좌표값으로 저장 후 칼만필터를 이용해서 추적하게 처리
def distance(pre_frame, current_frame):
min_num = []
for pre in range(0, len(pre_frame)):
min_dis = math.sqrt((pre_frame[pre][0] - current_frame[0][0]) *
(pre_frame[pre][0] - current_frame[0][0]) +
(pre_frame[pre][1] - current_frame[0][1]) *
(pre_frame[pre][1] - current_frame[0][1]))
for curr in range(1, len(current_frame)):
dis = math.sqrt((pre_frame[pre][0] - current_frame[curr][0]) *
(pre_frame[pre][0] - current_frame[curr][0]) +
(pre_frame[pre][1] - current_frame[curr][1]) *
(pre_frame[pre][1] - current_frame[curr][1]))
if min_dis > dis:
#!/usr/bin/env python
import freenect
import cv2
import frame_convert2
import numpy as np
import math, time, io, sys
from collections import deque
from time import sleep
import gpiozero
### GLOBAL VARIABLES
kernel = np.ones((3, 3), np.uint8) #small structuring element
kernel_big = np.ones((9, 9), np.uint8) #big structuring element
backSub = cv2.createBackgroundSubtractorKNN()
backSub_depth = cv2.createBackgroundSubtractorKNN(history=100,
dist2Threshold=400.0,
detectShadows=True)
CACHE_SIZE = 4 # size of the list that stores previous distance values, must be 4 or greater
if CACHE_SIZE < 4: CACHE_SIZE = 4
pre_distances = deque(
[10000] * CACHE_SIZE
) # stores previous distances of the two biggest blobs to recognize valid movement
BLOB_MAX_SIZE = 40000
BLOB_MIN_SIZE = 1000
IMG_DEPTH = 0
IMG_RGB = 1
THRESHOLD = 814
DEPTH = 152
TIME_BETWEEN_FRAMES = .3 # good values for testing .3 (fast), 1 (slow)
RELAY_PIN = 21
import numpy as np
import cv2
color = (12, 255, 148) #框图颜色
knn = cv2.createBackgroundSubtractorKNN(detectShadows=True)
#去掉静态背景
es = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
#得到椭圆的核
camera = cv2.VideoCapture('sWasteBasket.avi')
def drawCnt(fn, cnt):
if cv2.contourArea(cnt) > 1400:
#(x, y, w, h) = cv2.boundingRect(cnt)
#cv2.rectangle(fn, (x, y), (x + w, y + h), color, 2)
rect = cv2.minAreaRect(cnt)
#得出最小矩形
box = cv2.boxPoints(rect)
#得出该矩形的四个顶点
box = np.int64(box)
#转为整型数据
fire = cv2.drawContours(frame, [box], 0, color, 2)
framecount = 0
while True:
ret, frame = camera.read()
framecount += 1
if not ret:
break
#当ret为None时，视频结束
frame = cv2.resize(frame, (480, 320))
def __init__(self):
self.backgroundSubtractor = cv2.createBackgroundSubtractorKNN(
history=500, dist2Threshold=400, detectShadows=True)
def main():
global color, roiPoints, inputMode, itter
cv2.namedWindow('color')
cv2.setMouseCallback('color', selectROI)
cv2.createTrackbar('tb1', 'color', 1, 10, handleTrackbar)
termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 80, 1)
roiBox = None
quit = False
tracker = cv2.Tracker_create('TLD')
tracker_init = False
tracker_box = (263.0,462.0,98,51)
fgbg = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=400, detectShadows=True)
firstFrame = None
while True:
frames = listener.waitForNewFrame()
color = frames["color"]
ir = frames["ir"]
depth = frames["depth"]
kernel = np.ones((5,5),np.uint8)
registration.apply(color, depth, undistorted, registered)
color = cv2.resize(color.asarray(), (int(1920/2), int(1080/2)))
hsv = cv2.cvtColor(color, cv2.COLOR_BGR2HSV)
fgmask = fgbg.apply(hsv)
gray = cv2.cvtColor(color, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (21, 21), 0)
if firstFrame is None:
firstFrame = gray
# frameDelta = cv2.absdiff(firstFrame, gray)
# thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]
# thresh = cv2.dilate(thresh, None, iterations=10)
#
# _, cnts, _ = cv2.findContours(thresh.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
#
# for c in cnts:
# if cv2.contourArea(c) < 500:
# continue
# (cx, cy, cw, ch) = cv2.boundingRect(c)
# cv2.rectangle(color, (cx, cy), (cx+cw, cy+ch), (0,0,255), 2)
if roiBox is not None:
backProj = cv2.calcBackProject([fgmask], [0], roiHist, [0, 180], 1)
if not tracker_init:
tracker.init(hsv, (roiBox[0], roiBox[1], roiBox[2] - roiBox[0], roiBox[3] - roiBox[1]))
tracker_init = True
(r, roiBox) = cv2.CamShift(backProj, roiBox, termination)
(r2, tracker_box) = tracker.update(hsv)
p1 = (int(tracker_box[0]), int(tracker_box[1]))
p2 = (int(tracker_box[0] + tracker_box[2]), int(tracker_box[1] + tracker_box[3]))
cv2.rectangle(hsv, p1, p2, (250,0,0), 2)
cv2.rectangle(color, p1, p2, (250,0,0), 2)
pts = np.int0(cv2.boxPoints(r))
cv2.polylines(color, [pts], True, (0, 255, 0), 2)
cv2.polylines(hsv, [pts], True, (0, 255, 0), 2)
cv2.imshow('hsv', hsv)
cv2.imshow('color', color)
cv2.imshow('frame', fgmask)
key = cv2.waitKey(1) & 0xFF
if key == ord("i") and len(roiPoints) < 4:
inputMode = True
while len(roiPoints) < 4:
cv2.imshow("color", color)
cv2.waitKey(0)
roiPoints = np.array(roiPoints)
s = roiPoints.sum(axis=1)
tl = roiPoints[np.argmin(s)]
br = roiPoints[np.argmax(s)]
roi = hsv[tl[1]:br[1], tl[0]:br[0]]
roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
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 key == ord('q'):
quit = True
listener.release(frames)
if quit:
break
exec code
for i in [1,50,100,150,200,250]:
code='''avg%s=vid.get_data(%s)'''%(str(i), i)
exec code
from skimage import io
io.imshow(avg1-avg100)
io.imshow(avg1+avg100)
io.imshow(avg1+avg100+avg150)
io.imshow(avg1+avg100+avg150+avg200)
cv2.accumulateWeighted(vid.get_data(10), avg1, 1)
cv2.accumulateWeighted(vid.get_data(102), avg1, 1)
io.imshow(avg1-avg100)
io.imshow(reversed(avg1-avg100))
io.imshow((avg1+avg100))
fgbg= cv2.createBackgroundSubtractorKNN()
fgmask = fgbg.apply(avg1)
io.imshow(fgmask)
fgbg= cv2.createBackgroundSubtractorMOG2()
fgmask = fgbg.apply(avg1)
io.imshow(fgmask)
fgbg= cv2.createBackgroundSubtractorMOG2(1000)
fgbg.getBackgroundImage()
io.imshow(fgbg.getBackgroundImage())
io.imshow(fgmask)
fgbg= cv2.createBackgroundSubtractorMOG()
fgbg= cv2.createBackgroundSubtractorMOG2()
fgbg.apply(ivg1, ivg100)
fgbg.apply(avg1, avg100)
a = fgbg.apply(avg1, avg100)
io.imshow(a)
def __init__(self, *args):
# self.video = "data/vtest.avi"
# self._camera = cv2.VideoCapture(self.video) # 参数0表示第一个摄像头
self._camera = cv2.VideoCapture(0) # 参数0表示第一个摄像头
# 等待两秒
time.sleep(3)
# 判断视频是否打开
if (self._camera.isOpened()):
print('Open')
else:
print('摄像头未打开')
self._vedioWidth = int(self._camera.get(cv2.CAP_PROP_FRAME_WIDTH))
self._vedioHeight = int(self._camera.get(cv2.CAP_PROP_FRAME_HEIGHT))
self._showSize = 400
# self._vedioWidth = int(self._showSize)
# self._vedioHeight = 300 # int(self._showSize)
self._locationX = 0
self._locationY = 0
self._locationHeight = 0
self._locationWidth = 0
self._locationXOld = 0
self._locationYOld = 0
self._findTargetNumber = 0
self._isOutputResult = False
self._outputFile = None
self._outputFileName = None
self._outputFileExcel = None
self._outputFileNameExcel = None
print("vedio size", self._vedioWidth, self._vedioHeight)
# 目标检测
self._motionDetected = False
self._debugMode = False
self._bsknn = cv2.createBackgroundSubtractorKNN(detectShadows=True)
self._isKnnDetect = False
self._findTargetList = []
self._findTargetListOld = []
self._lineList = []
self._startDetectTime = 0
self._endDetectTime = 0
self._sameFindTargetNumber = 0
self._targetquen = deque()
self._targetNewIndexList = []
#输出数据
self._outputData = []
self._outputDataHeaders = ('时间', '说明', '数量', '位置X', '位置X', '宽度', '高度',
'速度dx', '速度dy')
self._outputDataFile = tablib.Dataset(*self._outputData,
headers=self._outputDataHeaders)
# 加载主窗口
super(MyWindow, self).__init__(*args)
# loadUi("mainwindow.ui", self) # 通过uic的loadUi加载UI
self.ui = Ui_mainWindow()
self.ui.setupUi(self)
# self.ui.label_ShowImg.resize(self._vedioWidth, self._vedioHeight)
self.setWindowIcon(QIcon("./icon.png"))
# 设置窗口固定大小
# self.setFixedHeight(380)
# self.setFixedWidth(640)
# 显示监控视频
self.timer = QTimer(self)
self.count = 0
self.timer.timeout.connect(self.objectTrackingKNN)
self.startCount()
# 加载信号与槽
self.ui.pushButtonBeginDetection.clicked.connect(self.beginDetection)
self.ui.pushButtonEndDetection.clicked.connect(self.endDetection)
self.ui.pushButtonOutputData.clicked.connect(self.outputData)
def test_KNN(video, output):
cap = cv2.VideoCapture(video)
fgbg = cv2.createBackgroundSubtractorKNN(detectShadows=True)
history = 0
fgbg.setHistory(history)
# 1. 获取视频码率、格式：
fps = cap.get(cv2.CAP_PROP_FPS) # opencv3没有cv.CV_
size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
codec = (cap.get(cv2.CAP_PROP_FOURCC))
print(fps, size, codec)
# 2. 指定写视频的格式, I420-avi, MJPG-mp4
fourcc = cv2.VideoWriter_fourcc(*'DIVX')
videoWriter = cv2.VideoWriter(output, int(codec), fps, size)
# 3. 针对问题四指定 帧号：
frame_list = []
frames = 0
while cap.isOpened():
ret, frame = cap.read()
if ret == True:
# cv2.waitKey(1000 // int(fps))
fgmask = fgbg.apply(frame) # , learningRate=0.01
if frames < history: # 初始延迟等待
frames += 1
continue
# 对原始帧进行膨胀去噪
th = cv2.threshold(fgmask.copy(), 244, 255, cv2.THRESH_BINARY)[1]
th = cv2.erode(th,
cv2.getStructuringElement(cv2.MORPH_ELLIPSE,
(3, 3)),
iterations=2)
dilated = cv2.dilate(th,
cv2.getStructuringElement(
cv2.MORPH_ELLIPSE, (8, 3)),
iterations=2)
# 获取所有检测框
image, contours, hier = cv2.findContours(dilated,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# 当前帧号获取：
frame_now = int(cap.get(cv2.CAP_PROP_POS_FRAMES))
if len(contours) >= 2:
print('frame_now:', frame_now, len(contours))
frame_list.append(frame_now)
# 保存视频
videoWriter.write(image)
cv2.imshow('frame', fgmask)
cv2.imshow("back", image)
k = cv2.waitKey(3000) & 0xff
if k == 27:
continue
else:
print('finished.')
break
print(frame_list)
cap.release()
videoWriter.release()
cv2.destroyAllWindows()
fgmask = fgbg.apply(frame)
result = cv2.bitwise_and(frame,frame,mask=fgmask)
elif mode == 3:
beta = 0.9
fgmask = fgbg.apply(frame)
result = cv2.bitwise_and(bg,bg,mask=fgmask)
result = cv2.addWeighted(bg,beta,result,1-beta, 0.0)
return result
if __name__ == '__main__':
# ウェブカメラからキャプチャを取得
cap = cv2.VideoCapture(1)
global bg
#fgbg = cv2.createBackgroundSubtractorMOG2(detectShadows=False)
fgbg = cv2.createBackgroundSubtractorKNN(detectShadows=False)
mode = 0
while(True):
# 操作部
c = cv2.waitKey(1)
if c == 'm': # 漫画風
mode = 1
elif c == 'f': # 前景抽出
mode = 2
elif c == 'o': # 原画像
mode = 0
elif c == 't': # 透明人間
mode = 3
_,bg = cap.read()
elif c == 'q' | c == 27: # 終了
pts = deque(maxlen=100000)
posx = deque(maxlen=constant.DECK)
posy = deque(maxlen=constant.DECK)
counter = 0
(dX, dY) = (0, 0)
direction = ""
startTime = datetime.now()
cv2.destroyAllWindows()
# From warp.py
fgbg1 = cv2.createBackgroundSubtractorMOG2(history=5000, varThreshold=20)
fgbg2 = cv2.createBackgroundSubtractorMOG2(history=5000, varThreshold=100)
fgbg3 = cv2.createBackgroundSubtractorKNN(history=5000, dist2Threshold=250)
for_er = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, constant.ERODE)
for_di = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, constant.DILATE)
# for_di1 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
# out = cv2.VideoWriter("Uca_detection.avi",
# cv2.VideoWriter_fourcc("M", "J", "P", "G"), 24, (464, 464))
if constant.MANUAL_ANNOTATION is True:
try:
name = video_name + "_" + str(
input("* Please enter name for this individual: "))
# species = str(input("* Please enter species name for this individual: "))
# sex = str(input("* Please enter sex for this individual: "))
# handedness = str(input(" *Please enter handedness for this individual: "))
def start_expt(self):
if self.use_arduino:
self.expt_timestring = time.strftime("%Y-%m-%d") + " " + time.strftime("%H.%M.%S") + " " + '- {} Hz {} Pulse width'.format(self.led_freq, self.led_dur)
else:
self.expt_timestring = time.strftime("%Y-%m-%d") + " " + time.strftime("%H.%M.%S")
#create new directory for the data we are about to generate
self.save_dir = '{}'.format(os.path.abspath(os.path.join(self.default_save_dir,self.expt_timestring)))
if not os.path.isdir(self.save_dir):
os.makedirs(self.save_dir)
self.parent_conn.send('Time:{}'.format(self.expt_timestring))
time.sleep(0.25)
self.parent_conn.send('Start!')
#give a bit of time for the child process to get started
time.sleep(0.25)
# Implement a K-Nearest Neighbors background subtraction
# Most efficient when number of foreground pixels is low (and image area is small)
# So we will create one background subtractor for each ROI
self.bg_sub_dict = {roi_name:cv2.createBackgroundSubtractorKNN(5,300,False) for roi_name in self.roi_list}
prev_time_stamp = 0
self.max_q_size = 0
#setup a dictionary of lists for analysis results
self.plotting_dict = {}
#setup a ditionary of deques for plotting
self.results_dict = {}
for roi_name in self.roi_list:
self.results_dict[roi_name] = list()
self.plotting_dict[roi_name] = deque(maxlen=100)
#initialize matplotlib plots for raw group activity
act_fig, act_axes = self.init_activity_plots()
#do an initial subplot background save
backgs = [ax.figure.canvas.copy_from_bbox(ax.bbox) for ax in chain(*act_axes)]
lns = [ax.plot([],[])[0] for ax in chain(*act_axes)]
msg = None
#Python "dot" loop optimization:
#see: https://wiki.python.org/moin/PythonSpeed/PerformanceTips
if hasattr(self, 'expt_conn_obj'):
expt_conn_obj_poll = self.expt_conn_obj.poll
expt_conn_obj_recv = self.expt_conn_obj.recv
data_q_get = self.data_q.get
np_ndarray = np.ndarray
data_q_qsize = self.data_q.qsize
sys_stdout_flush = sys.stdout.flush
get_activity_counts = self.get_activity_counts
bg_sub_dict = self.bg_sub_dict
roi_dict = self.roi_dict
roi_list = self.roi_list
show_tracking = self.show_tracking
update_plots = self.update_plots
#profiler.enable()
while True:
if hasattr(self, 'expt_conn_obj'):
if expt_conn_obj_poll():
msg = expt_conn_obj_recv()
if msg == 'Shutdown!':
self.shutdown_expt_manager()
time_stamp, frame, stim_bool = data_q_get()
#check if the experiment data collection has completed
if type(frame) == str:
if frame == 'stop':
#let's close everything down
cv2.destroyAllWindows()
#clean up the expt control process
self.data_q.close()
self.data_q.join_thread()
self.child_conn.close()
self.parent_conn.close()
self.control_expt_process.terminate()
break
elif type(frame) == np_ndarray:
#print frame.dtype, frame.size
#print (time_stamp, stim_bool)
fps = 1/(time_stamp-prev_time_stamp)
prev_time_stamp = time_stamp
print('Lagged frames: {} fps: {}'.format(int(data_q_qsize()),fps))
sys_stdout_flush()
if int(data_q_qsize() > self.max_q_size):
self.max_q_size = data_q_qsize()
#order of result sublists should be ['line1', 'line2', 'roi1', 'roi2', 'roi3', 'roi4']
results = [get_activity_counts(roi_name, bg_sub_dict[roi_name], frame, roi_dict[roi_name]) for roi_name in roi_list]
roi_counts, roi_frames = zip(*results)
for roi_indx, roi_name in enumerate(roi_list):
#append roi_counts to the results dictionary
self.results_dict[roi_name].append([time_stamp, roi_counts[roi_indx], stim_bool])
#append roi_counts to the plotting deque
self.plotting_dict[roi_name].append([time_stamp, roi_counts[roi_indx]])
#only display every 3rd tracked frame
#Results in massive speedup
if update_plots.calls % 3 == 0:
show_tracking(roi_frames)
#resave the backgrounds with drawn data but only if update_plots has been called near the plotting_dict deque length
if update_plots.calls % 99 == 0:
backgs = [ax.figure.canvas.copy_from_bbox(ax.bbox) for ax in chain(*act_axes)]
update_plots(act_axes, lns, backgs)
#profiler.disable()
#profiler.dump_stats(os.path.join(desktop_path,"Stats.dmp"))
#update plots one more time after experiment loop has finished so user can see overall activity results
update_plots(act_axes,lns,backgs)
#Okay we've finished analyzing all them data. Time to save it out.
if self.write_csv:
import csv
results_keys = sorted(self.results_dict.keys())
for key in results_keys:
with open("{}/{}-{}.csv".format(self.save_dir, self.expt_timestring, key), "wb") as outfile:
writer = csv.writer(outfile)
writer.writerow(["Time Elapsed (sec)", "Number of active flies", "Stimulation"])
writer.writerows(self.results_dict[key])
print("CSVs written to data folder!")
else:
print("Experiment is complete! Ready for the next one!")
def main():
counter = 0
dq = Queue()
displayInput = Thread(target=display, args=(dq, ))
displayInput.daemon = True
displayInput.start()
mt = MultiTracker.MultiTracker()
cap = FileVideoStream('fish7.mp4').start()
time.sleep(1.0)
frame = cap.read()
vh, vw = frame.shape[:2]
subtractor = cv2.createBackgroundSubtractorKNN(history=50,
dist2Threshold=120,
detectShadows=False)
# subtractor = cv2.createBackgroundSubtractorMOG2(history=120, varThreshold=100, detectShadows=False)
fps.start()
while cap.more():
# frame = cv2.flip(frame, 1)
small_frame = cv2.resize(frame,
dsize=None,
dst=None,
fx=(50 / 100),
fy=(50 / 100),
interpolation=cv2.INTER_LANCZOS4)
filtered_frame = small_frame.copy()
trackers = mt.update(small_frame)
if len(trackers) > 0:
for tracker in trackers:
c, bbox = tracker
offset = 0
xy1 = (int(bbox[0]) - offset, int(bbox[1]) - offset)
xy2 = (int(bbox[2]) + offset, int(bbox[3]) + offset)
cv2.rectangle(small_frame, xy1,
((xy1[0] + xy2[0]), (xy1[1] + xy2[1])),
(0, 0, 255), 1)
cv2.putText(small_frame, 'id: {}'.format(c),
(xy1[0], xy1[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1,
(0, 0, 0), 1, cv2.LINE_AA)
cv2.rectangle(filtered_frame, xy1,
((xy1[0] + xy2[0]), (xy1[1] + xy2[1])),
(255, 255, 255), -1)
grayFrame = cv2.cvtColor(filtered_frame, cv2.COLOR_BGR2GRAY)
# cv2.imshow('gray', grayFrame)
grayFrame = cv2.GaussianBlur(grayFrame, (5, 5), 0)
mask = subtractor.apply(grayFrame)
mask = cv2.morphologyEx(mask,
cv2.MORPH_OPEN,
np.ones((5, 5), np.uint8),
iterations=2)
mask = cv2.morphologyEx(mask,
cv2.MORPH_CLOSE,
np.ones((5, 5), np.uint8),
iterations=2)
mask = cv2.bitwise_and(grayFrame, grayFrame, mask=mask)
# H = cv2.Sobel(mask, cv2.CV_8U, 0, 1)
# V = cv2.Sobel(mask, cv2.CV_8U, 1, 0)
# mask = H + V
cv2.imshow('mask', mask)
cv2.waitKey(30)
_, threshold = cv2.threshold(mask, 25, 150, 0)
contours, hierarchy = cv2.findContours(threshold, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
x, y, w, h = cv2.boundingRect(contour)
if x >= int(vw / 4) and x <= int((vw / 4) + 3):
counter += 1
mt.add(counter, small_frame, (int(x), int(y), int(w), int(h)))
else:
small_frame = cv2.rectangle(small_frame, (x, y),
(x + w, y + h), (0, 0, 255),
cv2.FILLED)
small_frame = cv2.resize(small_frame,
dsize=None,
dst=None,
fx=(2),
fy=(2),
interpolation=cv2.INTER_LANCZOS4)
fps.stop()
fps.update()
# print(fps.fps())
cv2.imshow('t', small_frame)
cv2.waitKey(0)
dq.put(small_frame)
frame = cap.read()
print('Main thread done, waiting all thread queue to be done')
dq.join()
print('ENDING')
cap.stop()
['finger', 'up', 'moveup'], ['finger', 'down', 'movedown'],
['finger', 'clockwise', 'zoomin'],
['finger', 'anticlockwise', 'zoomout'],
['palm', 'left', 'turnleft'], ['palm', 'right', 'turnright'],
['palm', 'up', 'close'], ['palm', 'down', 'return'],
['palm', 'clockwise', 'ok'],
['palm', 'anticlockwise', 'cancel']]
# 记录手形识别数据[手部面积占比范围，手部最小外接图像宽高比范围，手形名称]
handdata = []
# videoProcessing函数中用
handTrackLen = 15 # 跟踪的手部运动轨迹长度
handTrack = list([(0, 0)] * handTrackLen) # 记录手部轨迹坐标元组的循环列表
hPoint = 0 # handTrack列表当前位置指针
conHandTrackLen = 8 # 用连续conHandTrackLen次轨迹判定结果生成最终轨迹，影响灵敏度，不大于handTrackLen
conHandTrack = list(['static'] * conHandTrackLen) # 记录手部轨迹识别结果，循环列表
handShapes = list([None] * conHandTrackLen) # 记录手形的循环列表，用于平滑手形识别结果
tPoint = 0 # conHandTrack列表当前位置指针
# 背景建模，用于手部分割，history设小了，停顿的手会成为背景，影响检测
frameBackGround = cv2.createBackgroundSubtractorKNN(history=500,
detectShadows=False)
TrackingHand = None # 正在跟踪的手部对象,Kalman滤波
# 调参、调试用=====================================
myTrackBar = None # 调节工具条，主要供调节颜色参数用
myPlot = None # 绘图工具，主要供查看颜色直方图调参用
# ================================================
import freenect
import cv2
import frame_convert2
import numpy as np
import math, time, io, sys
from collections import deque
from time import sleep
import gpiozero
### GLOBAL VARIABLES
KERNEL = np.ones((3, 3), np.uint8)
KERNEL_BIG = np.ones((9, 9), np.uint8)
# Create two independent background substractors, because RGB and depth image might need different parameters:
# NOTE: ADAPT THE RGB SUBSTRACTOR PARAMETERS ON THE LOCATION YOU SET UP THE KINECT TO GET BEST RECOGNITION:
backSubDepth = cv2.createBackgroundSubtractorKNN(history=10000,
dist2Threshold=50,
detectShadows=0)
backSubRgb = cv2.createBackgroundSubtractorKNN(
history=10000, dist2Threshold=400,
detectShadows=1) # use default parameters
#backSub = cv2.createBackgroundSubtractorMOG2() # performed worse then KNN
CACHE_SIZE = 4 # size of the list that stores previous distance values, must be 4 or greater
if CACHE_SIZE < 4: CACHE_SIZE = 4
pre_distances = deque(
[10000] * CACHE_SIZE
) # stores previous distances of the two biggest blobs to recognize valid movement
BLOB_MAX_SIZE = 40000
BLOB_MIN_SIZE = 3000
IMG_DEPTH = 0
IMG_RGB = 1
THRESHOLD = 814
import cv2
import numpy as np
knn = cv2.createBackgroundSubtractorKNN(detectShadows = True)
es = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (20,12))
camera = cv2.VideoCapture("/home/d3athmast3r/Downloads/traffic.flv")
def drawCnt(fn, cnt):
if cv2.contourArea(cnt) > 1400:
(x, y, w, h) = cv2.boundingRect(cnt)
cv2.rectangle(fn, (x, y), (x + w, y + h), (255, 255, 0), 2)
while True:
ret, frame = camera.read()
if not ret:
break
fg = knn.apply(frame.copy())
fg_bgr = cv2.cvtColor(fg, cv2.COLOR_GRAY2BGR)
bw_and = cv2.bitwise_and(fg_bgr, frame)
draw = cv2.cvtColor(bw_and, cv2.COLOR_BGR2GRAY)
draw = cv2.GaussianBlur(draw, (21, 21), 0)
draw = cv2.threshold(draw, 10, 255, cv2.THRESH_BINARY)[1]
draw = cv2.dilate(draw, es, iterations = 2)
image, contours, hierarchy = cv2.findContours(draw.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
for c in contours:
drawCnt(frame, c)
cv2.imshow("motion detection", frame)
if cv2.waitKey(1000 / 12) & 0xff == ord("q"):
break
camera.release()
def __init__(self, window_size=None, img_shape=None):
import cv2
self.fgbg = cv2.createBackgroundSubtractorKNN(detectShadows=True)
self.kern = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
def main():
# camera = cv2.VideoCapture(path.join(path.dirname(__file__), "traffic.flv"))
camera = cv2.VideoCapture(path.join(path.dirname(__file__), "768x576.avi"))
# camera = cv2.VideoCapture(path.join(path.dirname(__file__), "..", "movie.mpg"))
# camera = cv2.VideoCapture(0)
history = 20
# KNN background subtractor
bs = cv2.createBackgroundSubtractorKNN()
# MOG subtractor
# bs = cv2.bgsegm.createBackgroundSubtractorMOG(history = history)
# bs.setHistory(history)
# GMG
# bs = cv2.bgsegm.createBackgroundSubtractorGMG(initializationFrames = history)
cv2.namedWindow("surveillance")
pedestrians = {}
firstFrame = True
frames = 0
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480))
while True:
print " -------------------- FRAME %d --------------------" % frames
grabbed, frame = camera.read()
if (grabbed is False):
print "failed to grab frame."
break
fgmask = bs.apply(frame)
# this is just to let the background subtractor build a bit of history
if frames < history:
frames += 1
continue
th = cv2.threshold(fgmask.copy(), 127, 255, cv2.THRESH_BINARY)[1]
th = cv2.erode(th, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3)), iterations = 2)
dilated = cv2.dilate(th, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (8,3)), iterations = 2)
image, contours, hier = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
counter = 0
for c in contours:
if cv2.contourArea(c) > 500:
(x,y,w,h) = cv2.boundingRect(c)
cv2.rectangle(frame, (x,y), (x+w, y+h), (0, 255, 0), 1)
# only create pedestrians in the first frame, then just follow the ones you have
if firstFrame is True:
pedestrians[counter] = Pedestrian(counter, frame, (x,y,w,h))
counter += 1
for i, p in pedestrians.iteritems():
p.update(frame)
firstFrame = False
frames += 1
cv2.imshow("surveillance", frame)
out.write(frame)
if cv2.waitKey(110) & 0xff == 27:
break
out.release()
camera.release()
rh = statistics.mode(rightheight)
avgw = (lw+rw)/2
avgh = (lh+rh)/2
print(int(avgw),int(avgh))
# t = int(time.time())*1000
# print(time.time()*1000)
# Going Through Video again
# Reading Video
cap = cv2.VideoCapture('2.mp4')
# Background Subtraction
mask = cv2.createBackgroundSubtractorKNN(history=1, dist2Threshold=15, detectShadows=False)
# Making matrix for Erosion, dilation and morphing
kernel = np.ones((2, 2), np.uint8)
kernel1 = np.ones((1, 2), np.uint8)
it = 0
countL = 0
countR = 0
pLx=0
pLy=0
pRx=0
pRy=0
pLw=0
pRw=0
pLh=0
pRh=0
