import cv2
cap=cv2.VideoCapture('D:\Image\Funny.mp4')
while(cap.isOpened()):
    ret,frame=cap.read() #循環(huán)播放視頻中每幀圖像
    gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY) #將原幀圖像轉(zhuǎn)化為灰度圖像
    cv2.imshow('視頻捕捉',gray) #顯示處理后的圖像
    if cv2.waitKey(1) & 0xFF==ord('q'): #按q鍵退出程序
        break
cap.release() #處理完成，釋放視頻捕捉
cv2.destroyAllWindows() #關(guān)閉窗口釋放資源

#攝像頭獲取視頻
import cv2
cap=cv2.VideoCapture(1) #打開攝像頭獲取視頻
while(True):
    ret,frame=cap.read() #循環(huán)播放視頻中每幀圖像
    gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
    #顯示結(jié)果
    cv2.imshow('攝像頭拍照',gray)
    if cv2.waitKey(1) & 0xFF==ord('q'):
        break
cap.release()#處理完成，釋放視頻捕捉
cv2.destroyAllWindows()

#通過OpenCv獲取視頻并寫入
import cv2
cap2=cv2.VideoCapture('D:\Image\Funny.mp4')
cap=cv2.VideoCapture(1)#打開攝像頭并獲取視頻
#對視頻幀率fps進(jìn)行賦值
fps=24
#過去視頻幀的大小
size=(int(cap2.get(cv2.CAP_PROP_FRAME_WIDTH)),int(cap2.get(cv2.CAP_PROP_FRAME_HEIGHT)))
fourcc=cv2.VideoWriter_fourcc('X','V','I','D')  #MP4文件格式
out=cv2.VideoWriter('D:\Image\output.avi',fourcc,fps,size)#定義視頻文件寫入對象
while(cap.isOpened()):
    ret,frame=cap.read()
    if ret==True:
        '''
        獲取幀圖像并翻轉(zhuǎn)，cv2.flip()的第二個參數(shù)表示翻轉(zhuǎn)方式：0代表垂直翻轉(zhuǎn)，1代表水平翻轉(zhuǎn)，-1代表水平垂直翻轉(zhuǎn)
        '''
        frame=cv2.flip(frame,1)
        out.write(frame)#將翻轉(zhuǎn)后的幀圖像寫入文件
        cv2.imshow('幀圖像處理',frame)
        if cv2.waitKey(1) & 0xFF==ord('q'):
            break
    else:
        break
cap.release()
out.release()
cv2.destroyAllWindows()

#L-K算法
import numpy as np
import cv2
#設(shè)置L-K算法參數(shù)
lk_params=dict(winSize=(15,15), #搜索窗口的大小
                        maxLevel=2,#最大金字塔層數(shù)
                        #迭代算法終止條件（迭代次數(shù)或迭代閾值）
                        criteria=(cv2.TERM_CRITERIA_EPS|cv2.TERM_CRITERIA_COUNT,10,0.03))
feature_params=dict(maxCorners=500,   #設(shè)置最多返回的關(guān)鍵點（角點）數(shù)
                    qualityLevel=0.3,  #角點閾值：反映一個像素點對強才算一個角點
                    minDistance=7, #角點之間的最小像素點（歐氏距離）
                    blockSize=7) #計算一個像素點是否為關(guān)鍵點時所取區(qū)域的大小
class App:
    #構(gòu)造方法，初始化一些參數(shù)和視頻路徑
    def __init__(self,video_src):
        self.track_len=10 #光流標(biāo)記長度
        self.detect_interval=5#幀檢測間隔
        #跟蹤點幾何初始化，self.tracks中值的格式時：（前一幀角點）
        self.tracks=[]
        self.cam=cv2.VideoCapture(video_src) #視頻源
        self.frame_idx=0 #幀序列號初始化
    def run(self): #運行光流方法
        while True:
            ret,frame=self.cam.read()
            if ret ==True:
                frame_gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
                vis=frame.copy()
                #檢測到角點后光流跟蹤
                if len(self.tracks)>0:
                    img0,img1=self.prev_gray,frame_gray
                    p0=np.float32([tr[-1] for tr in self.tracks]).reshape(-1,1,2)
                    #將前一幀的角點和當(dāng)前幀的圖像作為輸入的角點在當(dāng)前幀的位置
                    p1,st,err=cv2.calcOpticalFlowPyrLK(img0,img1,p0,None,**lk_params)
                    #將當(dāng)前幀跟蹤到的角點以及圖像和前一幀的圖像作為輸入得到前一幀的角點檢測
                    p0r,st,err=cv2.calcOpticalFlowPyrLK(img1,img0,p1,None,**lk_params)
                    #得到角點回溯與前一幀實際角點的位置變化系
                    d=abs(p0-p0r).reshape(-1,2).max(-1)
                    good=d<1 #判斷d的值是否小于1
                    new_tracks=[]
                    #將跟蹤的點列為成功跟蹤點
                    for tr,(x,y),good_flag in zip(self.tracks,p1.reshape(-1,2),good):
                        if not good_flag:
                            continue
                        tr.append((x,y))
                        if (len(tr)>self.track_len):
                            del tr[0]
                        new_tracks.append(tr)
                        cv2.circle(vis,(x,y),2,(0,255,0),-1)
                    self.tracks=new_tracks
                    #以前一幀角點為初始點，以當(dāng)前幀跟蹤到的點為終點劃線，開始軌跡標(biāo)記
                    cv2.polylines(vis,[np.int32(tr) for tr in self.tracks],False,(0,255,0))
                    #每五幀檢測一次
                if (self.frame_idx % self.detect_interval==0):
                    mask=np.zeros_like(frame_gray)#初始化和視頻尺寸大小相同的圖像
                    mask[:]=255 #計算全部圖像的角點
                    for x,y in [np.int32(tr[-1]) for tr in self.tracks]:
                        cv2.circle(mask,(x,y),5,0,-1)
            #利用goodFeaturesToTrack進(jìn)行角點檢測
                    p=cv2.goodFeaturesToTrack(frame_gray,mask=mask,**feature_params)
                    if p is not None:
                        for x,y in np.float32(p).reshape(-1,2):
                            self.tracks.append([(x,y)]) #將檢測到的角點放在預(yù)跟蹤序列
                    self.frame_idx+=1
                    self.prev_gray=frame_gray
                    cv2.imshow('Lucas-Kanade光流算法',vis)
                    ch=0xFF & cv2.waitKey(1)
                    if ch==ord('q'):#按q鍵退出
                        break
def main():
    import sys    
    video_src='D:\Image\haha.mp4'    
    App(video_src).run() #運行主程序
    cv2.destroyAllWindows()
if __name__=='__main__':
    main() 

#基于稠密光流算法軌跡標(biāo)記
from numpy import *
import cv2
#定義光流跟蹤標(biāo)記函數(shù)
def draw_flow(im,flow,step=16):
    h,w=im.shape[:2]
    y,x=mgrid[step/2:h:step,step/2:w:step].reshape(2,-1)
    fx,fy=flow[y.astype(int),x.astype(int)].T
    #創(chuàng)建標(biāo)記線條端點
    lines=vstack([x,y,x+fx,y+fy]).T.reshape(-1,2,2)
    lines=int32(lines)
    #創(chuàng)建圖像和進(jìn)行線條標(biāo)記
    vis=cv2.cvtColor(im,cv2.COLOR_GRAY2BGR)
    for (x1,y1),(x2,y2) in lines:
        cv2.line(vis,(x1,y1),(x2,y2),(0,255,0),1)
        cv2.circle(vis,(x1,y1),1,(0,255,0),-1)#畫圓
    return vis
cap=cv2.VideoCapture(1)#開啟攝像頭
#讀取視頻幀
ret,im=cap.read()
#轉(zhuǎn)化為灰度圖像
prev_gray=cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
while True:
    #讀取視頻幀
    ret,im=cap.read()
    #轉(zhuǎn)換為灰度圖像
    gray=cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
    #光流計算
    flow=cv2.calcOpticalFlowFarneback(prev_gray,gray,None,0.5,3,15,3,5,1.2,0)
    prev_gray=gray
    #繪制光流軌跡
    cv2.imshow('稠密光流算法',draw_flow(gray,flow))
    if cv2.waitKey(1)&0xFF==ord('q'): #按q鍵結(jié)束
        break
im.release()
cv2.destroyAllWindows()

#利用幀間差分法進(jìn)行目標(biāo)檢測
import time
import cv2
import argparse #用于解析參數(shù)
import datetime #用于時間和日期相關(guān)處理
import imutils #用于圖像相關(guān)處理
import argparse
#創(chuàng)建參數(shù)解析器并解析參數(shù)
ap=argparse.ArgumentParser()
ap.add_argument('-v','--video',help='path to the video file')
ap.add_argument('-a','--min-area',type=int,default=500,help='minimum area size')
args=vars(ap.parse_args(args=[])) #這里有兩種表達(dá)式，JUPYTER只能使用這種，表示默認(rèn)參數(shù),pycharme可以用另一種
#如果video參數(shù)為None，那么我們從攝像頭讀取數(shù)據(jù)
if args.get('video',None) is None:
        camera=cv2.VideoCapture(1)
        if camera is None:
            print("請檢查攝像頭連接")
            exit()
            time.sleep(0.25)
        else:
        #讀取一個視頻
            camera=cv2.VideoCapture('D:\Image\haha.mp4')
'''
初始化視頻流的第一幀。一般情況下，視頻第一幀不會包含運動而僅僅是背景
''' 
firstFrame=None
#遍歷視頻的每一幀
while True:
    '''
    獲取當(dāng)前視幀并初始化顯示文本，調(diào)用camera.read()將返回一個二元組，元組的第一個值是True和False，表明是否成功從緩沖中讀取幀圖像，元組的第二個值就是獲取的當(dāng)前幀圖像的值。
    '''
    (grabbed,frame)=camera.read()
    text='No Motion Detected'
    #如果不能獲取到幀，說明到了視頻的結(jié)尾
    if not grabbed:
        break
    frame=imutils.resize(frame,width=500) #調(diào)整幀圖像大小
    gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY) #轉(zhuǎn)換為灰度圖像
    gray=cv2.GaussianBlur(gray,(21,21),0)#高斯模糊處理
#如果第一幀是None，對其進(jìn)行初始化
    if firstFrame is None:
        firstFrame=gray
        continue
#將當(dāng)前幀和第一幀圖像對應(yīng)的像素點的灰度值相減并求絕對值來計算兩幀的不同
    frameDelta=cv2.absdiff(firstFrame,gray)
#對差分圖像進(jìn)行閾值處理來顯示圖像中像素點的灰度值有所變化的區(qū)域
    thresh=cv2.threshold(frameDelta,25,255,cv2.THRESH_BINARY)[1]
#擴(kuò)展閾值圖像填充空洞，然后找到閾值圖像中的輪廓
    thresh=cv2.dilate(thresh,None,iterations=2)
    '''
cv2.findContours()函數(shù)返回3個值，第一個是所處理的圖像，第二個是輪廓，第三個是每個輪廓對應(yīng)的屬性
'''
    contours,hierrarchy=cv2.findContours(thresh.copy(),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE) #老版返回3個接受參數(shù)，新版返回兩個;
    #遍歷輪廓
    for c in contours:
    #過濾小的，不相關(guān)的輪廓，如果輪廓面積大于min_area，則在前景和移動區(qū)域畫邊框
        if cv2.contourArea(c)<args['min_area']:
            continue
    #計算輪廓的邊界框，在當(dāng)前幀中畫出該框并更新相應(yīng)文本
        (x,y,w,h)=cv2.boundingRect(c)
        cv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),2)
        text='Motion Detected'
#在當(dāng)前幀上寫文本及時間戳
    cv2.putText(frame,'Room Status:{}'.format(text),(10,20),cv2.FONT_HERSHEY_SIMPLEX,0.5,(0,0,255),2)
    cv2.putText(frame,datetime.datetime.now().strftime('%A %%d %B %Y %I:%M:%S%p'),(10,frame.shape[0]-10),cv2.FONT_HERSHEY_SIMPLEX,0.35,(0,0,255),1)
    #顯示當(dāng)前幀并記錄用戶是否按了鍵
    cv2.imshow('視頻監(jiān)控演示',frame)
    cv2.imshow('閾值輪廓圖像',thresh)
    cv2.imshow('幀差分圖像',frameDelta)
    key=cv2.waitKey(1)
    if key==ord('q'):
        break #跳出循環(huán)
#釋放攝像機資源并關(guān)閉打開的窗口
camera.release()
cv2.destroyAllWindows()

#運動方向檢測
import cv2
import numpy as np
import queue  #導(dǎo)入庫主要用于隊列處理
camera=cv2.VideoCapture(1)
if camera is None:
    print('請檢查攝像頭鏈接')
    exit()
width=int(camera.get(3))
height=int(camera.get(4))
 
#參數(shù)初始化
firstFrame=None
lastDec=None
firstThresh=None
feature_params=dict(maxCorners=100, #設(shè)置最多返回的關(guān)鍵點數(shù)
                    qualityLevel=0.3, #角點閾值：響應(yīng)最大值
                    minDistance=7, #角點之間最少像素點（歐氏距離）
                    blockSize=7) #計算一個像素點是否為關(guān)鍵點時所取區(qū)域
#Lucas-Kanade 光流算法參數(shù)設(shè)置
lk_params=dict(winSize=(15,15),#搜索窗口的大小
                maxLevel=2,#最大金字塔層數(shù)
                criteria=(cv2.TermCriteria_EPS|cv2.TERM_CRITERIA_COUNT,10,0.03))
color=np.random.randint(0,255,(100,3))
num=0
#隊列初始化
q_x=queue.Queue(maxsize=10)
q_y=queue.Queue(maxsize=10)
while True:
    #獲取視頻幀并轉(zhuǎn)化為灰度圖像
    (grabbed,frame)=camera.read()
    gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
    gray=cv2.GaussianBlur(gray,(21,21),0)
    if firstFrame is None:
        firstFrame=gray
        continue
    frameDelta=cv2.absdiff(firstFrame,gray)
    #對圖像進(jìn)行閾值二值化
    thresh=cv2.threshold(frameDelta,25,255,cv2.THRESH_BINARY)[1]
 
    p0=cv2.goodFeaturesToTrack(thresh,mask=None,**feature_params)
    if p0 is not None:
        x_sum=0
        y_sum=0
        for i,old in enumerate(p0):
            x,y=old.ravel()
            x_sum+=x
            y_sum+=y
        x_avg=x_sum/len(p0)
        y_avg=y_sum/len(p0)
        if q_x.full():
            qx_list=list(q_x.queue)
            key=0
            diffx_sum=0
            for item_x in qx_list:
                key+=1
                if key<10:
                    diff_x=item_x-qx_list[key]
                    diffx_sum+=diff_x
                if diffx_sum<0 and x_avg<500:#表明隊列在增加
                    print('Left')
                    cv2.putText(frame,'Left Motion Detected',(100,100),0,0.5,(0,0,255),2)
                else:
                     print("Right")
                     cv2.putText(frame,"Right Motion Detected",(300,100),0,0.5,(255,0,255),2)
            q_x.get()
            q_x.put(x_avg)
            cv2.putText(frame,str(x_avg),(300,100),0,0.5,(0,0,255),2)
            frame=cv2.circle(frame,(int(x_avg),int(y_avg)),5,color[i].tolist(),-1)
        cv2.imshow('運動方向檢測',frame)
        firstFrame=gray.copy()
        key=cv2.waitKey(1)&0xFF
        if key==ord('q'):
            break
camera.release()
cv2.destroyAllWindows()