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)鍵點(diǎn)（角點(diǎn)）數(shù)
                    qualityLevel=0.3,  #角點(diǎn)閾值：反映一個像素點(diǎn)對強(qiáng)才算一個角點(diǎn)
                    minDistance=7, #角點(diǎn)之間的最小像素點(diǎn)（歐氏距離）
                    blockSize=7) #計算一個像素點(diǎn)是否為關(guān)鍵點(diǎn)時所取區(qū)域的大小
class App:
    #構(gòu)造方法，初始化一些參數(shù)和視頻路徑
    def __init__(self,video_src):
        self.track_len=10 #光流標(biāo)記長度
        self.detect_interval=5#幀檢測間隔
        #跟蹤點(diǎn)幾何初始化，self.tracks中值的格式時：（前一幀角點(diǎn)）
        self.tracks=[]
        self.cam=cv2.VideoCapture(video_src) #視頻源
        self.frame_idx=0 #幀序列號初始化
    def run(self): #運(yùn)行光流方法
        while True:
            ret,frame=self.cam.read()
            if ret ==True:
                frame_gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
                vis=frame.copy()
                #檢測到角點(diǎn)后光流跟蹤
                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)
                    #將前一幀的角點(diǎn)和當(dāng)前幀的圖像作為輸入的角點(diǎn)在當(dāng)前幀的位置
                    p1,st,err=cv2.calcOpticalFlowPyrLK(img0,img1,p0,None,**lk_params)
                    #將當(dāng)前幀跟蹤到的角點(diǎn)以及圖像和前一幀的圖像作為輸入得到前一幀的角點(diǎn)檢測
                    p0r,st,err=cv2.calcOpticalFlowPyrLK(img1,img0,p1,None,**lk_params)
                    #得到角點(diǎn)回溯與前一幀實(shí)際角點(diǎn)的位置變化系
                    d=abs(p0-p0r).reshape(-1,2).max(-1)
                    good=d<1 #判斷d的值是否小于1
                    new_tracks=[]
                    #將跟蹤的點(diǎn)列為成功跟蹤點(diǎn)
                    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
                    #以前一幀角點(diǎn)為初始點(diǎn)，以當(dāng)前幀跟蹤到的點(diǎn)為終點(diǎn)劃線，開始軌跡標(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 #計算全部圖像的角點(diǎn)
                    for x,y in [np.int32(tr[-1]) for tr in self.tracks]:
                        cv2.circle(mask,(x,y),5,0,-1)
            #利用goodFeaturesToTrack進(jìn)行角點(diǎ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)]) #將檢測到的角點(diǎn)放在預(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() #運(yùn)行主程序
    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)記線條端點(diǎn)
    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')
'''
初始化視頻流的第一幀。一般情況下，視頻第一幀不會包含運(yùn)動而僅僅是背景
''' 
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)的像素點(diǎn)的灰度值相減并求絕對值來計算兩幀的不同
    frameDelta=cv2.absdiff(firstFrame,gray)
#對差分圖像進(jìn)行閾值處理來顯示圖像中像素點(diǎ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)
#釋放攝像機(jī)資源并關(guān)閉打開的窗口
camera.release()
cv2.destroyAllWindows()

#運(yùn)動方向檢測
import cv2
import numpy as np
import queue  #導(dǎo)入庫主要用于隊(duì)列處理
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)鍵點(diǎn)數(shù)
                    qualityLevel=0.3, #角點(diǎn)閾值：響應(yīng)最大值
                    minDistance=7, #角點(diǎn)之間最少像素點(diǎn)（歐氏距離）
                    blockSize=7) #計算一個像素點(diǎn)是否為關(guān)鍵點(diǎ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
#隊(duì)列初始化
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:#表明隊(duì)列在增加
                    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('運(yùn)動方向檢測',frame)
        firstFrame=gray.copy()
        key=cv2.waitKey(1)&0xFF
        if key==ord('q'):
            break
camera.release()
cv2.destroyAllWindows()